kunt

irc.go (7077B)

---

 // Copyright 2013 TLH and dsp. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package irc
 
 import (
 	"crypto/tls"
 	"encoding/json"
 	"fmt"
 	"io/ioutil"
 	"log"
 	"net"
 	"strings"
 	"sync"
 )
 
 type Context struct {
 	conn        net.Conn        // actual connection
 	outgoingMsg chan Message    // TX messaging channel
 	incomingMsg chan Message    // RX messaging channel
 	ev          []Event         // slice of callbacks
 	evnum       int             // number of callbacks
 	network     network         // irc network state
 	intercepts  []*chan Message // intercept chans
 	sync.Mutex
 }
 
 type Config struct {
 	NetworkName string    // network name
 	Nick        string    // nickname
 	User        string    // username
 	RealName    string    // real name
 	Pass        string    // password
 	Serv        string    // server address
 	Port        string    // server port
 	Ssl         bool      // enable/disable ssl
 	Ipv6        bool      // enable/disable ipv6 (not implemented)
 	Channels    []string  // array of channels to join
 }
 
 type Channel struct {
 	name   string // name of irc channel
 	key    string // password for irc channel
 	joined bool   // whether we have joined this channel or not
 }
 
 type network struct {
 	name     string    // network name
 	nick     string    // nickname
 	user     string    // username
 	realName string    // real name
 	pass     string    // password
 	serv     string    // server address
 	port     string    // server port
 	tls      bool      // enable/disable ssl
 	ipv6     bool      // enable/disable ipv6 (not implemented)
 	channels []Channel // slice of channels
 }
 
 func LoadConfig(fname string) (con *Config, err error) {
 	bytes, err := ioutil.ReadFile(fname)
 	if err != nil {
 		log.Printf(" [LoadConfig] error reading file %s\n", fname)
 		return nil, err
 	}
 	con = new(Config)
 	err = json.Unmarshal(bytes, &con)
 	if err != nil {
 		log.Printf(" [LoadConfig] error reading file %s\n", fname)
 		return nil, err
 	}
 	return con, nil
 }
 
 // Create a new IrcContext
 func NewIrcContext(ircConfig Config) *Context {
 	chans := make([]Channel, len(ircConfig.Channels))
 
 	for i, _ := range chans {
 		chans[i] = Channel{ircConfig.Channels[i],"",false}
 	}
 
 	network := network{
 		name:     ircConfig.NetworkName,
 		nick:     ircConfig.Nick,
 		user:     ircConfig.User,
 		realName: ircConfig.RealName,
 		pass:     ircConfig.Pass,
 		serv:     ircConfig.Serv,
 		port:     ircConfig.Port,
 		tls:      ircConfig.Ssl,
 		ipv6:     ircConfig.Ipv6,
 		channels: chans,
 	}
 
 	return &Context{
 		outgoingMsg: make(chan Message),
 		incomingMsg: make(chan Message),
 		ev:          make([]Event, 0),
 		network:     network,
 		intercepts:  make([]*chan Message, 0),
 	}
 }
 
 func (i *Context) AddIntercept(a *chan Message) {
 	i.Lock()
 	defer i.Unlock()
 	i.intercepts = append(i.intercepts, a)
 }
 
 func (i *Context) DelIntercept(ap *chan Message) error {
 	i.Lock()
 	defer i.Unlock()
 	for j := 0; j < len(i.intercepts); j++ {
 		if ap == i.intercepts[j] {
 			if j == 0 {
 				i.intercepts = make([]*chan Message, 0)
 				return nil
 			}
 			i.intercepts = append(i.intercepts[:j], i.intercepts[j+1:]...)
 			return nil
 		}
 	}
 	return fmt.Errorf("Intercept not found")
 }
 
 type ChanIter func() (c *Channel, ok bool)
 
 func MakeChanIter(i *Context) ChanIter {
 	j := 0
 	return func() (c *Channel, ok bool) {
 		i.Lock()
 		defer i.Unlock()
 		if j < len(i.network.channels) {
 			j++
 			return &i.network.channels[j], true
 		}
 		return nil, false
 	}
 }
 
 func (i *Context) JoinChannel(c string, key string) {
 	i.Lock()
 	defer i.Unlock()
 	found := false
 	for _, v := range i.network.channels {
 		if v.name == c {
 			found = true
 			break
 		}
 	}
 	if !found {
 		i.network.channels = append(i.network.channels,
 			Channel{c, key, false})
 	}
 	for j, v := range i.network.channels {
 		if v.name != c {
 			continue
 		}
 		if !v.joined {
 			i.Join(v.name, v.key)
 			i.network.channels[j].joined = true
 			break
 		} else {
 			i.Join(v.name, v.key)
 			break
 		}
 	}
 	return
 }
 
 func (i *Context) JoinChannels() {
 	for _, v := range i.network.channels {
 		i.JoinChannel(v.name, v.key)
 	}
 }
 
 func (i *Context) PartChannel(s string, text string) error {
 	i.Lock()
 	defer i.Unlock()
 	for c, v := range i.network.channels {
 		if v.name == s {
 			if v.joined {
 				i.Part(s, text)
 				i.network.channels[c].joined = false
 				return nil
 			} else {
 				return fmt.Errorf("Channel %s is not joined", s)
 			}
 		}
 	}
 	return fmt.Errorf("Can't find channel %s", s)
 }
 
 // Connect to the server.  Do not join any channels by default.
 func (i *Context) Connect() error {
 	service := i.network.serv + ":" + i.network.port
 
 	if i.network.tls {
 		if conf, err := loadCerts(); err != nil {
 			return err
 		} else {
 			if conn, err := tls.Dial("tcp", service, conf); err != nil {
 				return err
 			} else {
 				i.conn = conn
 			}
 		}
 	} else {
 		if conn, err := net.Dial("tcp", service); err != nil {
 			return err
 		} else {
 			i.conn = conn
 		}
 	}
 
 	// Fire off the goroutines now!
 	go i.incomingMsgLoop()
 	go i.outgoingMsgLoop()
 	go i.rxRawMessages()
 
 	return nil
 }
 
 // Login to server
 func (i *Context) Login() {
 	if i.network.pass != "" {
 		i.Pass()
 	}
 	i.Nick()
 	i.User()
 }
 
 func (i *Context) read(buf []byte) (int, error) {
 	n, err := i.conn.Read(buf)
 	if err != nil {
 		return n, err
 	}
 	return n, nil
 }
 
 // This is the actual raw read loop.  Here we parse the incoming bytes
 // and form messages.
 func (i *Context) rxRawMessages() error {
 	for {
 		var buf [512]byte
 		n, err := i.read(buf[0:])
 		if err != nil {
 			return err
 		}
 		if n != 0 {
 			log.Println(string(buf[0 : n-1]))
 			s := string(buf[0:n])
 
 			msg, err := i.ParseRawMessage(s)
 			if err != nil {
 				log.Printf("%s", err)
 			} else {
 				i.incomingMsg <- *msg
 				for _, v := range i.intercepts {
 					*v <- *msg
 				}
 			}
 		}
 	}
 	return nil
 }
 
 // Transmit a raw message
 func (i *Context) TxRawMessage(msg []byte) error {
 	_, err := i.conn.Write(msg[0:])
 	if err != nil {
 		return err
 	}
 	return nil
 }
 
 func (i *Context) String() string {
 	s := fmt.Sprintf("IRC CONTEXT DUMP")
 	if len(i.ev) == 0 {
 		s += fmt.Sprintf("\n\tEvent handlers: [NONE]\n")
 	} else {
 		s += fmt.Sprintf("\n\tEvent handlers: [%d]\n", len(i.ev))
 		for _, v := range i.ev {
 			s += fmt.Sprintf("\t\tCommand: %s\n", v.Command)
 		}
 	}
 	s += fmt.Sprintf("\tNetwork:\n")
 	s += fmt.Sprintf("\t\tName: %s\n", i.network.name)
 	s += fmt.Sprintf("\t\tNick: %s\n", i.network.nick)
 	s += fmt.Sprintf("\t\tUser: %s\n", i.network.user)
 	if i.network.pass != "" {
 		s += fmt.Sprintf("\t\tPass: %s\n", i.network.pass)
 	} else {
 		s += fmt.Sprintf("\t\tPass: [NONE]\n")
 	}
 	s += fmt.Sprintf("\t\tServer: %s\n", i.network.serv)
 	if i.network.tls {
 		s += fmt.Sprintf("\t\tTLS: on")
 	} else {
 		s += fmt.Sprintf("\t\tTLS: off")
 	}
 	if len(i.network.channels) == 0 {
 		s += fmt.Sprintf("\n\t\tChannels: [NONE]")
 	} else {
 		s += fmt.Sprintf("\n\t\tChannels: [%d]\n", len(i.network.channels))
 		for _, v := range i.network.channels {
 			s += fmt.Sprintf("\t\t\tName: %s\n", v.name)
 		}
 	}
 	return strings.TrimSpace(s)
 }