go/r3-netstatus/r3xmppbot/r3xmppbot.go

   1 // (c) Bernhard Tittelbach, 2013
   2
   3 package r3xmppbot
   4
   5 import (
   6         "crypto/tls"
   7         "encoding/json"
   8         "errors"
   9         "os"
  10         "path"
  11         "strings"
  12         "time"
  13
  14         xmpp "code.google.com/p/goexmpp"
  15 )
  16
  17 func (botdata *XmppBot) makeXMPPMessage(to string, message interface{}, subject interface{}) *xmpp.Message {
  18         xmppmsgheader := xmpp.Header{To: to,
  19                 From:     botdata.my_jid_,
  20                 Id:       <-xmpp.Id,
  21                 Type:     "chat",
  22                 Lang:     "",
  23                 Innerxml: "",
  24                 Error:    nil,
  25                 Nested:   make([]interface{}, 0)}
  26
  27         var msgsubject, msgbody *xmpp.Generic
  28         switch cast_msg := message.(type) {
  29         case string:
  30                 msgbody = &xmpp.Generic{Chardata: cast_msg}
  31         case *string:
  32                 msgbody = &xmpp.Generic{Chardata: *cast_msg}
  33         case *xmpp.Generic:
  34                 msgbody = cast_msg
  35         default:
  36                 msgbody = &xmpp.Generic{}
  37         }
  38         switch cast_msg := subject.(type) {
  39         case string:
  40                 msgsubject = &xmpp.Generic{Chardata: cast_msg}
  41         case *string:
  42                 msgsubject = &xmpp.Generic{Chardata: *cast_msg}
  43         case *xmpp.Generic:
  44                 msgsubject = cast_msg
  45         default:
  46                 msgsubject = &xmpp.Generic{}
  47         }
  48         return &xmpp.Message{Header: xmppmsgheader, Subject: msgsubject, Body: msgbody, Thread: &xmpp.Generic{}}
  49 }
  50
  51 func (botdata *XmppBot) makeXMPPPresence(to, ptype, show, status string) *xmpp.Presence {
  52         xmppmsgheader := xmpp.Header{To: to,
  53                 From:     botdata.my_jid_,
  54                 Id:       <-xmpp.Id,
  55                 Type:     ptype,
  56                 Lang:     "",
  57                 Innerxml: "",
  58                 Error:    nil,
  59                 Nested:   make([]interface{}, 0)}
  60         var gen_show, gen_status *xmpp.Generic
  61         if len(show) == 0 {
  62                 gen_show = nil
  63         } else {
  64                 gen_show = &xmpp.Generic{Chardata: show}
  65         }
  66         if len(status) == 0 {
  67                 gen_status = nil
  68         } else {
  69                 gen_status = &xmpp.Generic{Chardata: status}
  70         }
  71         return &xmpp.Presence{Header: xmppmsgheader, Show: gen_show, Status: gen_status}
  72 }
  73
  74 type R3JIDDesire int
  75
  76 const (
  77         R3NoChange  R3JIDDesire = -1
  78         R3NeverInfo R3JIDDesire = iota // ignore first value by assigning to blank identifier
  79         R3OnlineOnlyInfo
  80         R3OnlineOnlyWithRecapInfo
  81         R3AlwaysInfo
  82         R3DebugInfo
  83 )
  84
  85 const (
  86         ShowOnline       string = ""
  87         ShowAway         string = "away"
  88         ShowNotAvailabe  string = "xa"
  89         ShowDoNotDisturb string = "dnd"
  90         ShowFreeForChat  string = "chat"
  91 )
  92
  93 type JidData struct {
  94         Online bool
  95         Wants  R3JIDDesire
  96 }
  97
  98 type JabberEvent struct {
  99         JID       string
 100         Online    bool
 101         Wants     R3JIDDesire
 102         StatusNow bool
 103 }
 104
 105 type XMPPMsgEvent struct {
 106         Msg              string
 107         DistributeLevel  R3JIDDesire
 108         RememberAsStatus bool
 109 }
 110
 111 type XMPPStatusEvent struct {
 112         Show   string
 113         Status string
 114 }
 115
 116 type RealraumXmppNotifierConfig map[string]JidData
 117
 118 type XmppBot struct {
 119         jid_lastauthtime_  map[string]int64
 120         realraum_jids_     RealraumXmppNotifierConfig
 121         password_          string
 122         my_jid_            string
 123         auth_timeout_      int64
 124         config_file_       string
 125         my_login_password_ string
 126         xmppclient_        *xmpp.Client
 127         presence_events_   *chan interface{}
 128 }
 129
 130 func (data RealraumXmppNotifierConfig) saveTo(filepath string) {
 131         fh, err := os.Create(filepath)
 132         if err != nil {
 133                 Syslog_.Println(err)
 134                 return
 135         }
 136         defer fh.Close()
 137         enc := json.NewEncoder(fh)
 138         if err = enc.Encode(&data); err != nil {
 139                 Syslog_.Println(err)
 140                 return
 141         }
 142 }
 143
 144 func (data RealraumXmppNotifierConfig) loadFrom(filepath string) {
 145         fh, err := os.Open(filepath)
 146         if err != nil {
 147                 Syslog_.Println(err)
 148                 return
 149         }
 150         defer fh.Close()
 151         dec := json.NewDecoder(fh)
 152         if err = dec.Decode(&data); err != nil {
 153                 Syslog_.Println(err)
 154                 return
 155         }
 156         for to, jiddata := range data {
 157                 jiddata.Online = false
 158                 data[to] = jiddata
 159         }
 160 }
 161
 162 func (botdata *XmppBot) handleEventsforXMPP(xmppout chan<- xmpp.Stanza, presence_events <-chan interface{}, jabber_events <-chan JabberEvent) {
 163         var last_status_msg *string
 164
 165         defer func() {
 166                 if x := recover(); x != nil {
 167                         Syslog_.Printf("handleEventsforXMPP: run time panic: %v", x)
 168                 }
 169                 for _ = range jabber_events {
 170                 } //cleanout jabber_events queue
 171         }()
 172
 173         for {
 174                 select {
 175                 case pe, pe_still_open := <-presence_events:
 176                         if !pe_still_open {
 177                                 return
 178                         }
 179                         Debug_.Printf("handleEventsforXMPP<-presence_events: %T %+v", pe, pe)
 180                         switch pec := pe.(type) {
 181                         case xmpp.Stanza:
 182                                 xmppout <- pec
 183                                 continue
 184                         case string:
 185                                 for to, jiddata := range botdata.realraum_jids_ {
 186                                         if jiddata.Wants >= R3DebugInfo {
 187                                                 xmppout <- botdata.makeXMPPMessage(to, pec, nil)
 188                                         }
 189                                 }
 190
 191                         case XMPPStatusEvent:
 192                                 xmppout <- botdata.makeXMPPPresence("", "", pec.Show, pec.Status)
 193
 194                         case XMPPMsgEvent:
 195                                 if pec.RememberAsStatus {
 196                                         last_status_msg = &pec.Msg
 197                                 }
 198                                 for to, jiddata := range botdata.realraum_jids_ {
 199                                         if jiddata.Wants >= pec.DistributeLevel && ((jiddata.Wants >= R3OnlineOnlyInfo && jiddata.Online) || jiddata.Wants >= R3AlwaysInfo) {
 200                                                 xmppout <- botdata.makeXMPPMessage(to, pec.Msg, nil)
 201                                         }
 202                                 }
 203                         default:
 204                                 Debug_.Println("handleEventsforXMPP<-presence_events: unknown type received: quitting")
 205                                 return
 206                         }
 207
 208                 case je, je_still_open := <-jabber_events:
 209                         if !je_still_open {
 210                                 return
 211                         }
 212                         Debug_.Printf("handleEventsforXMPP<-jabber_events: %T %+v", je, je)
 213                         simple_jid := removeJIDResource(je.JID)
 214                         jid_data, jid_in_map := botdata.realraum_jids_[simple_jid]
 215
 216                         //send status if requested, even if user never changed any settings and thus is not in map
 217                         if last_status_msg != nil && je.StatusNow {
 218                                 xmppout <- botdata.makeXMPPMessage(je.JID, last_status_msg, nil)
 219                         }
 220
 221                         if jid_in_map {
 222                                 //if R3OnlineOnlyWithRecapInfo, we want a status update when coming online
 223                                 if last_status_msg != nil && !jid_data.Online && je.Online && jid_data.Wants == R3OnlineOnlyWithRecapInfo {
 224                                         xmppout <- botdata.makeXMPPMessage(je.JID, last_status_msg, nil)
 225                                 }
 226                                 jid_data.Online = je.Online
 227                                 if je.Wants > R3NoChange {
 228                                         jid_data.Wants = je.Wants
 229                                 }
 230                                 botdata.realraum_jids_[simple_jid] = jid_data
 231                                 botdata.realraum_jids_.saveTo(botdata.config_file_)
 232                         } else if je.Wants > R3NoChange {
 233                                 botdata.realraum_jids_[simple_jid] = JidData{je.Online, je.Wants}
 234                                 botdata.realraum_jids_.saveTo(botdata.config_file_)
 235                         }
 236                 }
 237         }
 238 }
 239
 240 func removeJIDResource(jid string) string {
 241         var jidjid xmpp.JID
 242         jidjid.Set(jid)
 243         jidjid.Resource = ""
 244         return jidjid.String()
 245 }
 246
 247 func (botdata *XmppBot) isAuthenticated(jid string) bool {
 248         authtime, in_map := botdata.jid_lastauthtime_[jid]
 249         return in_map && time.Now().Unix()-authtime < botdata.auth_timeout_
 250 }
 251
 252 const help_text_ string = "\n*auth*<password>* ...Enables you to use more commands.\n*time* ...Returns bot time."
 253 const help_text_auth string = "You are authorized to use the following commands:\n*off* ...You will no longer receive notifications.\n*on* ...You will be notified of r3 status changes while you are online.\n*on_with_recap* ...Like *on* but additionally you will receive the current status when you come online.\n*on_while_offline* ...You will receive all r3 status changes, wether you are online or offline.\n*status* ...Use it to query the current status.\n*time* ...Returns bot time.\n*bye* ...Logout."
 254
 255 //~ var re_msg_auth_    *regexp.Regexp     = regexp.MustCompile("auth\s+(\S+)")
 256
 257 func (botdata *XmppBot) handleIncomingMessageDialog(inmsg xmpp.Message, xmppout chan<- xmpp.Stanza, jabber_events chan JabberEvent) {
 258         if inmsg.Body == nil || inmsg.GetHeader() == nil {
 259                 return
 260         }
 261         bodytext_args := strings.Split(strings.Replace(inmsg.Body.Chardata, "*", " ", -1), " ")
 262         for len(bodytext_args) > 1 && len(bodytext_args[0]) == 0 {
 263                 bodytext_args = bodytext_args[1:len(bodytext_args)] //get rid of empty first strings resulting from " text"
 264         }
 265         bodytext_lc_cmd := strings.ToLower(bodytext_args[0])
 266         if botdata.isAuthenticated(inmsg.GetHeader().From) {
 267                 switch bodytext_lc_cmd {
 268                 case "on":
 269                         jabber_events <- JabberEvent{inmsg.GetHeader().From, true, R3OnlineOnlyInfo, false}
 270                         xmppout <- botdata.makeXMPPMessage(inmsg.GetHeader().From, "Receive r3 status updates while online.", "Your New Status")
 271                 case "off":
 272                         jabber_events <- JabberEvent{inmsg.GetHeader().From, true, R3NeverInfo, false}
 273                         xmppout <- botdata.makeXMPPMessage(inmsg.GetHeader().From, "Do not receive anything.", "Your New Status")
 274                 case "on_with_recap":
 275                         jabber_events <- JabberEvent{inmsg.GetHeader().From, true, R3OnlineOnlyWithRecapInfo, false}
 276                         xmppout <- botdata.makeXMPPMessage(inmsg.GetHeader().From, "Receive r3 status updates while and current status on coming, online.", "Your New Status")
 277                 case "on_while_offline":
 278                         jabber_events <- JabberEvent{inmsg.GetHeader().From, true, R3AlwaysInfo, false}
 279                         xmppout <- botdata.makeXMPPMessage(inmsg.GetHeader().From, "Receive all r3 status updates, even if you are offline.", "Your New Status")
 280                 case "debug":
 281                         jabber_events <- JabberEvent{inmsg.GetHeader().From, true, R3DebugInfo, false}
 282                         xmppout <- botdata.makeXMPPMessage(inmsg.GetHeader().From, "Debug mode enabled", "Your New Status")
 283                 case "bye", "quit", "logout":
 284                         botdata.jid_lastauthtime_[inmsg.GetHeader().From] = 0
 285                         xmppout <- botdata.makeXMPPMessage(inmsg.GetHeader().From, "Bye Bye !", nil)
 286                 case "open", "close":
 287                         xmppout <- botdata.makeXMPPMessage(inmsg.GetHeader().From, "Sorry, I'm just weak software, not strong enough to operate the door for you.", nil)
 288                 case "status":
 289                         jabber_events <- JabberEvent{inmsg.GetHeader().From, true, R3NoChange, true}
 290                 case "time":
 291                         xmppout <- botdata.makeXMPPMessage(inmsg.GetHeader().From, time.Now().String(), nil)
 292                 case "ping":
 293                         xmppout <- botdata.makeXMPPMessage(inmsg.GetHeader().From, "Pong with auth", nil)
 294                 default:
 295                         //~ auth_match = re_msg_auth_.FindStringSubmatch(inmsg.Body.Chardata)
 296                         xmppout <- botdata.makeXMPPMessage(inmsg.GetHeader().From, help_text_auth, nil)
 297                 }
 298         } else {
 299                 switch bodytext_lc_cmd {
 300                 case "hilfe", "help", "?", "hallo", "yes", "ja", "ja bitte", "bitte", "sowieso":
 301                         xmppout <- botdata.makeXMPPMessage(inmsg.GetHeader().From, help_text_, "Available Commands")
 302                 case "auth":
 303                         authindex := 1
 304                         for len(bodytext_args) > authindex && len(bodytext_args[authindex]) == 0 {
 305                                 authindex++
 306                         }
 307                         if len(bodytext_args) > authindex && bodytext_args[authindex] == botdata.password_ {
 308                                 botdata.jid_lastauthtime_[inmsg.GetHeader().From] = time.Now().Unix()
 309                                 xmppout <- botdata.makeXMPPMessage(inmsg.GetHeader().From, help_text_auth, nil)
 310                         }
 311                 case "status", "off", "on", "on_while_offline", "on_with_recap":
 312                         xmppout <- botdata.makeXMPPMessage(inmsg.GetHeader().From, "Sorry, you need to be authorized to do that.", nil)
 313                 case "time":
 314                         xmppout <- botdata.makeXMPPMessage(inmsg.GetHeader().From, time.Now().String(), nil)
 315                 case "ping":
 316                         xmppout <- botdata.makeXMPPMessage(inmsg.GetHeader().From, "Pong", nil)
 317                 case "":
 318                         xmppout <- botdata.makeXMPPMessage(inmsg.GetHeader().From, "You're a quiet one, aren't you?", nil)
 319                 default:
 320                         //~ auth_match = re_msg_auth_.FindStringSubmatch(inmsg.Body.Chardata)
 321                         xmppout <- botdata.makeXMPPMessage(inmsg.GetHeader().From, "A nice day to you too !\nDo you need \"help\" ?", nil)
 322                 }
 323         }
 324 }
 325
 326 func (botdata *XmppBot) handleIncomingXMPPStanzas(xmppin <-chan xmpp.Stanza, xmppout chan<- xmpp.Stanza, jabber_events chan JabberEvent) {
 327
 328         defer func() {
 329                 if x := recover(); x != nil {
 330                         Syslog_.Printf("handleIncomingXMPPStanzas: run time panic: %v", x)
 331                 }
 332         }()
 333
 334         var error_count int = 0
 335         var incoming_stanza interface{}
 336
 337         handleStanzaError := func() bool {
 338                 error_count++
 339                 if error_count > 15 {
 340                         Syslog_.Println("handleIncomingXMPPStanzas: too many errors in series.. bailing out")
 341                         botdata.StopBot()
 342                         return true
 343                 }
 344                 return false
 345         }
 346
 347         for incoming_stanza = range xmppin {
 348                 switch stanza := incoming_stanza.(type) {
 349                 case *xmpp.Message:
 350                         if stanza.GetHeader() == nil {
 351                                 continue
 352                         }
 353                         if stanza.Type == "error" || stanza.Error != nil {
 354                                 Syslog_.Printf("XMPP %T Error: %s", stanza, stanza)
 355                                 if stanza.Error.Type == "cancel" {
 356                                         // asume receipient not reachable -> disable
 357                                         Syslog_.Printf("Error reaching %s. Disabling user, please reenable manually", stanza.From)
 358                                         jabber_events <- JabberEvent{stanza.From, false, R3NeverInfo, false}
 359                                         continue
 360                                 }
 361                                 if handleStanzaError() {
 362                                         return
 363                                 }
 364                                 continue
 365                         } else {
 366                                 error_count = 0
 367                         }
 368                         botdata.handleIncomingMessageDialog(*stanza, xmppout, jabber_events)
 369                 case *xmpp.Presence:
 370                         if stanza.GetHeader() == nil {
 371                                 continue
 372                         }
 373                         if stanza.Type == "error" || stanza.Error != nil {
 374                                 Syslog_.Printf("XMPP %T Error: %s", stanza, stanza)
 375                                 if handleStanzaError() {
 376                                         return
 377                                 }
 378                                 continue
 379                         } else {
 380                                 error_count = 0
 381                         }
 382                         switch stanza.GetHeader().Type {
 383                         case "subscribe":
 384                                 xmppout <- botdata.makeXMPPPresence(stanza.GetHeader().From, "subscribed", "", "")
 385                                 jabber_events <- JabberEvent{stanza.GetHeader().From, true, R3NoChange, false}
 386                                 xmppout <- botdata.makeXMPPPresence(stanza.GetHeader().From, "subscribe", "", "")
 387                         case "unsubscribe", "unsubscribed":
 388                                 jabber_events <- JabberEvent{stanza.GetHeader().From, false, R3NeverInfo, false}
 389                                 botdata.jid_lastauthtime_[stanza.GetHeader().From] = 0 //logout
 390                                 xmppout <- botdata.makeXMPPPresence(stanza.GetHeader().From, "unsubscribe", "", "")
 391                         case "unavailable":
 392                                 jabber_events <- JabberEvent{stanza.GetHeader().From, false, R3NoChange, false}
 393                                 botdata.jid_lastauthtime_[stanza.GetHeader().From] = 0 //logout
 394                         default:
 395                                 jabber_events <- JabberEvent{stanza.GetHeader().From, true, R3NoChange, false}
 396                         }
 397
 398                 case *xmpp.Iq:
 399                         if stanza.GetHeader() == nil {
 400                                 continue
 401                         }
 402                         if stanza.Type == "error" || stanza.Error != nil {
 403                                 Syslog_.Printf("XMPP %T Error: %s", stanza, stanza)
 404                                 if handleStanzaError() {
 405                                         return
 406                                 }
 407                                 continue
 408                         } else {
 409                                 error_count = 0
 410                         }
 411
 412                         if HandleServerToClientPing(stanza, xmppout) {
 413                                 continue
 414                         } //if true then routine handled it and we can continue
 415                         Debug_.Printf("Unhandled Iq: %s", stanza)
 416                 }
 417         }
 418 }
 419
 420 func init() {
 421         //~ xmpp.Debug = &XMPPDebugLogger{}
 422         xmpp.Info = &XMPPDebugLogger{}
 423         xmpp.Warn = &XMPPLogger{}
 424 }
 425
 426 func NewStartedBot(loginjid, loginpwd, password, state_save_dir string, insecuretls bool) (*XmppBot, chan interface{}, error) {
 427         var err error
 428         botdata := new(XmppBot)
 429
 430         botdata.realraum_jids_ = make(map[string]JidData, 1)
 431         botdata.jid_lastauthtime_ = make(map[string]int64, 1)
 432         botdata.my_jid_ = loginjid
 433         botdata.my_login_password_ = loginpwd
 434         botdata.password_ = password
 435         botdata.auth_timeout_ = 3600 * 2
 436
 437         botdata.config_file_ = path.Join(state_save_dir, "r3xmpp."+removeJIDResource(loginjid)+".json")
 438
 439         xmpp.TlsConfig = tls.Config{InsecureSkipVerify: insecuretls}
 440         botdata.realraum_jids_.loadFrom(botdata.config_file_)
 441
 442         client_jid := new(xmpp.JID)
 443         client_jid.Set(botdata.my_jid_)
 444         botdata.xmppclient_, err = xmpp.NewClient(client_jid, botdata.my_login_password_, nil)
 445         if err != nil {
 446                 Syslog_.Println("Error connecting to xmpp server", err)
 447                 return nil, nil, err
 448         }
 449         if botdata.xmppclient_ == nil {
 450                 Syslog_.Println("xmpp.NewClient returned nil without error")
 451                 return nil, nil, errors.New("No answer from xmpp server")
 452         }
 453
 454         err = botdata.xmppclient_.StartSession(true, &xmpp.Presence{})
 455         if err != nil {
 456                 Syslog_.Println("'Error StartSession:", err)
 457                 return nil, nil, err
 458         }
 459
 460         roster := xmpp.Roster(botdata.xmppclient_)
 461         for _, entry := range roster {
 462                 Debug_.Print(entry)
 463                 if entry.Subscription == "from" {
 464                         botdata.xmppclient_.Out <- botdata.makeXMPPPresence(entry.Jid, "subscribe", "", "")
 465                 }
 466                 if entry.Subscription == "none" {
 467                         delete(botdata.realraum_jids_, entry.Jid)
 468                 }
 469         }
 470
 471         presence_events := make(chan interface{}, 1)
 472         jabber_events := make(chan JabberEvent, 1)
 473
 474         go func() {
 475                 for { //auto recover from panic
 476                         botdata.handleEventsforXMPP(botdata.xmppclient_.Out, presence_events, jabber_events)
 477                 }
 478         }()
 479         go func() {
 480                 for { //auto recover from panic
 481                         botdata.handleIncomingXMPPStanzas(botdata.xmppclient_.In, botdata.xmppclient_.Out, jabber_events)
 482                 }
 483         }()
 484
 485         botdata.presence_events_ = &presence_events
 486
 487         return botdata, presence_events, nil
 488 }
 489
 490 func (botdata *XmppBot) StopBot() {
 491         Syslog_.Println("Stopping XMPP Bot")
 492         if botdata.xmppclient_ != nil {
 493                 close(botdata.xmppclient_.Out)
 494         }
 495         if botdata.presence_events_ != nil {
 496                 *botdata.presence_events_ <- false
 497                 close(*botdata.presence_events_)
 498         }
 499         botdata.config_file_ = ""
 500         botdata.realraum_jids_ = nil
 501         botdata.xmppclient_ = nil
 502 }