func (i *IdentMod) Init(b *Bot, conn irc.SafeConn) (err error) {
conf := b.Config.Search("mod", "ident")
i.nick = conf.Search("nick")
if i.nick == "" {
i.nick = b.IrcConfig.Nick
}
i.pass = conf.Search("pass")
if i.pass == "" {
log.Printf("ident: no pass")
return nil
}
conn.AddHandler(irc.CONNECTED, func(c *irc.Conn, l irc.Line) {
go func() {
// curse you freenode NickServ..
time.Sleep(2 * time.Second)
c.Privmsg("nickserv", fmt.Sprintf("identify %s %s", i.nick, i.pass))
log.Printf("ident: identified")
time.Sleep(2 * time.Second)
c.Privmsg("nickserv", fmt.Sprintf("regain %s", i.nick))
log.Printf("ident: regained")
}()
})
return nil
}
func (m *StatMod) Init(b *Bot, conn irc.SafeConn) (err error) {
conf := b.Config.Search("mod", "stat")
m.db, err = sql.Open("sqlite3", conf.Search("path"))
if err != nil {
log.Printf("stat module failed to open %q: %s\n", conf.Search("path"), err)
return
}
for _, t := range tables {
_, err = m.db.Exec(t)
if err != nil {
log.Printf("stat module failed to create table: %s\n%q\n", err, t)
return
}
}
b.Hook("stat", func(b *Bot, sender, cmd string, args ...string) error {
if len(args) != 1 {
return fmt.Errorf("not enough arguments")
}
s, err := m.stat(args[0])
if err != nil {
return fmt.Errorf("stat failed for %q: %s", args[0], err)
}
if s == nil {
return fmt.Errorf("no such user: %s", args[0])
}
b.Conn.Privmsg(sender, s.String())
return nil
})
conn.AddHandler("PRIVMSG", func(c *irc.Conn, l irc.Line) {
if err := m.update(l.Src.String(), l.Args[1]); err != nil {
log.Printf("update failed for %q, %q: %s",
l.Src.String(),
l.Args[1:],
err,
)
}
})
conn.AddHandler(irc.ACTION, func(c *irc.Conn, l irc.Line) {
if err := m.action(l.Src.String()); err != nil {
log.Printf("action update failed for %q: %s",
l.Src.String(),
err,
)
}
})
log.Println("stat module initialised")
return nil
}
func (m *NotifyMod) Init(b *Bot, conn irc.SafeConn) error {
m.notes = make(map[string][]Note)
conn.AddHandler("PRIVMSG", func(con *irc.Conn, line irc.Line) {
args := strings.SplitN(line.Args[1], " ", 3)
if len(args) == 3 && args[0] == ".notify" {
note := Note{
from: line.Src.String(),
message: args[2],
sent: time.Now(),
}
m.notes[args[1]] = append(m.notes[args[1]], note)
conn.Privmsg(getContext(line), fmt.Sprintf("added note to %q: %q", args[1], note))
}
})
notify := func(conn *irc.Conn, line irc.Line) {
m.NotifyIfQueued(conn, line)
}
conn.AddHandler("PRIVMSG", notify)
conn.AddHandler("JOIN", notify)
return nil
}
func (m *MarkovMod) Init(b *Bot, conn irc.SafeConn) error {
//conf := b.Config.Search("mod", "markov")
c, err := NewChain(filepath.Join(b.DataDir, "markov"))
if err != nil {
return fmt.Errorf("error opening db: %s", err)
}
m.chain = c
generate := func() string {
return m.chain.Generate(rand.Intn(10) + 10)
}
b.Hook("markov", func(b *Bot, sender, cmd string, args ...string) error {
b.Conn.Privmsg(sender, generate())
return nil
})
conn.AddHandler("PRIVMSG", func(c *irc.Conn, l irc.Line) {
if strings.HasPrefix(l.Args[0], b.Magic) {
return
}
getAddressee := func(line string) string {
if s := strings.SplitN(line, " ", 2); len(s) == 2 {
t := rune(s[0][len(s[0])-1])
if strings.ContainsRune(":,", t) {
return s[0][:len(s[0])-1]
}
}
return ""
}
if addressee := getAddressee(l.Args[1]); addressee != "" {
if addressee == c.Me().String() {
c.Privmsg(l.Args[0], generate())
}
} else {
m.chain.Build(strings.NewReader(l.Args[1]))
}
})
log.Printf("markov module initialized")
return nil
}
func (w *WtmpMod) Init(b *Bot, conn irc.SafeConn) error {
conf := b.Config.Search("mod", "wtmp")
w.file = conf.Search("file")
w.last = time.Now()
w.cron = cron.New()
w.on = make(map[string]string)
channel := conf.Search("channel")
w.cron.AddFunc("@every 1m", func() {
//log.Printf("checking wtmp %s...", w.file)
wtmps, err := wtmp(w.file)
if err != nil {
log.Printf("error checking wtmp: %s", err)
return
}
for _, wtr := range wtmps {
if wtr.name != "" {
w.on[wtr.line] = wtr.name
}
if w.last.Before(wtr.date) {
log.Printf("wtmp: %q %q %q %q", wtr.line, wtr.name, wtr.host, wtr.date)
in := "in "
if wtr.name == "" {
in = "out"
wtr.name = w.on[wtr.line]
}
conn.Privmsg(channel, fmt.Sprintf("log%s: %s on %s", in, wtr.name, wtr.line))
}
}
w.last = time.Now()
})
go func() {
time.Sleep(10 * time.Second)
w.cron.Start()
}()
log.Printf("wtmp module initialized with file %s", w.file)
return nil
}
func (m *MailwatchMod) Init(b *Bot, conn irc.SafeConn) error {
conf := b.Config.Search("mod", "mailwatch")
dir := conf.Search("dir")
channel := conf.Search("channel")
if dir != "" {
m.dir = maildir.Dir(dir)
m.cronjob = cron.New()
m.cronjob.AddFunc("@every 1m", func() {
//log.Printf("checking mail %s...", m.dir)
if newmail, err := m.dir.Unseen(); err != nil {
conn.Privmsg(channel, fmt.Sprintf("maildir error: %s, err"))
} else {
l := len(newmail)
if l > 0 {
conn.Privmsg(channel, fmt.Sprintf("%d new mail:", l))
for _, k := range newmail {
hdr, err := m.dir.Header(k)
if err != nil {
conn.Privmsg(channel, fmt.Sprintf("maildir header error: %s", err))
} else {
conn.Privmsg(channel, fmt.Sprintf("from : %s", hdr.Get("From")))
conn.Privmsg(channel, fmt.Sprintf("subject: %s", hdr.Get("Subject")))
}
}
}
}
})
go func() {
time.Sleep(10 * time.Second)
m.cronjob.Start()
}()
log.Printf("mailwatch module initialized with dir: %s", dir)
}
return nil
}
func (g *AdventureMod) Init(b *Bot, conn irc.SafeConn) error {
conf := b.Config.Search("mod", "adventure")
channel := conf.Search("channel")
go func() {
var err error
time.Sleep(5 * time.Second)
for err == nil {
if err = g.spawn(); err != nil {
log.Printf("adventure spawn error: %s", err)
break
}
for g.out.Scan() {
line := g.out.Text()
log.Printf("adventure: %s", line)
conn.Privmsg(channel, line)
}
if err := g.out.Err(); err != nil {
log.Printf("adventure read error: %s", err)
}
}
}()
conn.AddHandler("PRIVMSG", func(c *irc.Conn, l irc.Line) {
args := strings.Split(l.Args[1], " ")
if args[0] == ".a" {
line := strings.Join(args[1:], " ")
log.Printf("adventure: writing %q", line)
if _, err := fmt.Fprintf(g.in, "%s\n", line); err != nil {
log.Printf("adventure: error writing to subprocess: %s", err)
}
}
})
log.Printf("adventure module initialized with channel %s", channel)
return nil
}
