an/ircd
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

using go modules, tidying up ...

Browse source
This commit is contained in:
Andreas Neue 2021-05-19 09:41:47 +02:00
parent 4dff342b70
commit 623a69d025
11 changed files with 563 additions and 74 deletions
Download patch file Download diff file Expand all files Collapse all files

242
irc/client.go Normal file
View file

@ -0,0 +1,242 @@
// vim:ts=4:sts=4:sw=4:noet:tw=72
package irc
import (
"bytes"
"fmt"
"io"
"net"
"strings"
"time"
"git.dnix.de/an/xlog"
)
type Client interface {
Name() string
Password() string
Register(bool)
Send(*Message)
Receive(*Message)
Destroy()
}
type RemoteClient struct {
server *Server
name string
password string
modes string
isSSL bool
isRegistered bool
isAuthed bool
isClosed bool
receive chan *Message
registered chan bool
conn net.Conn
writeq chan string
}
func NewRemoteClient(sv *Server, conn net.Conn) *RemoteClient {
cl := new(RemoteClient)
cl.server = sv
cl.name = ""
cl.password = ""
cl.modes = ""
cl.receive = make(chan *Message, 1024)
cl.registered = make(chan bool)
cl.isRegistered = false
cl.isAuthed = false
cl.isClosed = false
cl.conn = conn
cl.writeq = make(chan string, 1024)
go cl.connReader()
go cl.connWriter()
go cl.dispatcher()
xlog.Info("RemoteClient connected")
return cl
}
func (cl *RemoteClient) Name() string {
return cl.name
}
func (cl *RemoteClient) Password() string {
return cl.password
}
func (cl *RemoteClient) Register(success bool) {
cl.registered <- success
}
func (cl *RemoteClient) Send(msg *Message) {
msg.Pre = cl.name
cl.server.Dispatch(msg)
}
func (cl *RemoteClient) Receive(msg *Message) {
cl.receive <- msg
}
func (cl *RemoteClient) AddMode(mode string) {
cl.modes = cl.modes + mode
}
func (cl *RemoteClient) DelMode(mode string) {
cl.modes = strings.Replace(cl.modes, mode, "", -1)
}
func (cl *RemoteClient) HasMode(mode string) bool {
return strings.IndexRune(cl.modes, rune(mode[0])) != -1
}
func (cl *RemoteClient) Destroy() {
if cl.isClosed {
return
}
cl.isClosed = true
close(cl.writeq)
cl.conn.Write([]byte("ERROR :Closing link"))
cl.conn.Close()
if cl.name != "" {
xlog.Info("RemoteClient '%s' disconnected", cl.name)
} else {
xlog.Info("RemoteClient disconnected")
}
}
func (cl *RemoteClient) dispatcher() {
for {
time.Sleep(10 * time.Millisecond)
if cl.isClosed {
return
}
select {
case msg := <-cl.receive:
cl.writeMsg(msg)
case success := <-cl.registered:
if !success {
cl.name = ""
cl.Destroy()
xlog.Debug("User registration failed: '%s'", cl.name)
return
}
xlog.Debug("User '%s' registered", cl.name)
default:
continue
}
}
}
/*func (cl *RemoteClient) pinger() {
for {
time.Sleep(30 * time.Second)
if cl.isClosed {
return
}
cl.writeLine("PING %s", cl.server.host)
}
}*/
func (cl *RemoteClient) connReader() {
for {
time.Sleep(10 * time.Millisecond)
buf := make([]byte, 4096)
if cl.isClosed {
xlog.Debug("connReader: exiting")
return
}
cl.conn.SetReadDeadline(time.Now().Add(time.Second * 5))
n, err := cl.conn.Read(buf)
if err == io.EOF {
xlog.Info("connReader: Connection closed by peer")
cl.server.DelClient(cl)
return
}
if err != nil {
continue
}
raw := buf[:n]
raw = bytes.Replace(raw, []byte("\r\n"), []byte("\n"), -1)
raw = bytes.Replace(raw, []byte("\r"), []byte("\n"), -1)
lines := bytes.Split(raw, []byte("\n"))
for _, line := range lines {
if len(line) > 0 {
cl.handleCmd(string(line))
}
}
}
}
func (cl *RemoteClient) connWriter() {
for line := range cl.writeq {
time.Sleep(10 * time.Millisecond)
if cl.isClosed {
return
}
written := 0
bytes := []byte(line + "\r\n")
for written < len(line) {
cl.conn.SetWriteDeadline(time.Now().Add(time.Second * 5))
n, err := cl.conn.Write(bytes[written:])
if err == io.EOF {
xlog.Info("connWriter: Connection closed by peer")
cl.server.DelClient(cl)
return
} else if err != nil {
xlog.Error("connWriter: %s", err.Error())
cl.server.DelClient(cl)
return
}
written += n
}
}
xlog.Debug("connWriter: exiting")
}
func (cl *RemoteClient) writeMsg(msg *Message) {
clid := strings.ToLower(msg.Pre)
if _, exists := cl.server.clients[clid]; exists {
msg.Pre = msg.Pre + "!" + msg.Pre + "@" + cl.server.clHosts[clid]
}
cl.writeLine(msg.String())
}
func (cl *RemoteClient) writeLine(format string, a ...interface{}) {
cl.writeq <- fmt.Sprintf(format, a...)
}
func (cl *RemoteClient) handleCmd(s string) {
msg := Parse(s)
msg.Cmd = strings.ToUpper(msg.Cmd)
if cl.name != "" {
cl.Send(msg)
return
}
// If client name is not set, intercept cmds until we get one
switch msg.Cmd {
case "PASS":
cl.password = msg.Args[0]
case "NICK":
cl.name = msg.Args[0]
cl.server.AddClient(cl)
case "USER":
}
}
func checkAuth(cl *RemoteClient) {
if cl.name == "" || cl.password == "" {
return
}
}

67
irc/cluster.go Normal file
View file

@ -0,0 +1,67 @@
// vim:ts=4:sts=4:sw=4:noet:tw=72
package irc
import (
"strings"
"git.dnix.de/an/xlog"
nats "github.com/nats-io/nats.go"
)
type ClusterConnector struct {
conn *nats.Conn
subs map[string]*nats.Subscription
}
func NewClusterConnector(urls string, ssl bool) *ClusterConnector {
opts := nats.DefaultOptions
opts.Servers = strings.Split(urls, ",")
for i, s := range opts.Servers {
opts.Servers[i] = strings.Trim(s, " ")
}
opts.Secure = ssl
conn, err := opts.Connect()
if err != nil {
xlog.Error(err.Error())
}
subs := make(map[string]*nats.Subscription)
return &ClusterConnector{conn: conn, subs: subs}
}
func (cc *ClusterConnector) Subscribe(subj string, ch chan *Message) {
if cc.conn == nil {
return
}
if _, exists := cc.subs[subj]; exists {
return
}
sub, err := cc.conn.Subscribe(subj, func(n *nats.Msg) {
m := Parse(string(n.Data))
ch <- m
})
if err != nil {
xlog.Error(err.Error())
return
}
cc.subs[subj] = sub
}
func (cc *ClusterConnector) Unsubscribe(subj string) {
if cc.conn == nil {
return
}
if sub, exists := cc.subs[subj]; exists {
sub.Unsubscribe()
delete(cc.subs, subj)
}
}
func (cc *ClusterConnector) Publish(msg *Message) {
if cc.conn == nil {
return
}
subj := strings.ToLower(msg.Args[0])
cc.conn.Publish(subj, []byte(msg.String()))
}

283
irc/handlers.go Normal file
View file

@ -0,0 +1,283 @@
// vim:ts=4:sts=4:sw=4:noet:tw=72
package irc
import (
"fmt"
"strings"
"git.dnix.de/an/xlog"
)
type commandHook struct {
HookFn func(sv *Server, msg *Message)
MinArgs int
NeedTrail bool
NeedMode string
}
var svCommandHooks = map[string]commandHook{
"PRIVMSG": {handleCmdPrivmsg, 1, true, ""},
"JOIN": {handleCmdJoin, 1, false, ""},
"PART": {handleCmdPart, 1, false, ""},
"QUIT": {handleCmdQuit, 0, false, ""},
"MODE": {handleCmdMode, 1, false, ""},
"TOPIC": {handleCmdTopic, 1, false, ""},
"KICK": {handleCmdKick, 2, false, ""},
"NAMES": {handleCmdNames, 1, false, ""},
"WHO": {handleCmdWho, 1, false, ""},
"WHOIS": {handleCmdWhois, 0, false, ""},
"PING": {handleCmdPing, 1, false, ""},
"PONG": {handleCmdPong, 0, false, ""},
"REHASH": {handleCmdRehash, 0, false, "ao"},
"KILL": {handleCmdKill, 0, false, "ao"},
/*
"LIST": {handleCmdList, 0, false, false},
"VERSION": {handleCmdVersion, 0, false, false},
"STATS": {handleCmdStats, 0, false, false},
"TIME": {handleCmdTime, 0, false, false},
"OPER": {handleCmdOper, 1, false, false},
"ADMIN": {handleCmdAdmin, 0, false, false},
"INFO": {handleCmdInfo, 0, false, false},
"WHO": {handleCmdWho, 0, false, false},
"WHOWAS": {handleCmdWhowas, 0, false, false},
"PONG": {handleCmdPong, 0, false, false},
"ERROR": {handleCmdError, 0, false, false},
"AWAY": {handleCmdAway, 0, false, false},
"RESTART": {handleCmdRestart, 0, false, false},
"SUMMON": {handleCmdSummon, 0, false, false},
"USERS": {handleCmdUsers, 0, false, false},
"USERHOST": {handleCmdUserhost, 0, false, false},
"ISON": {handleCmdIson, 0, false, false},
*/
}
func handleCmdPrivmsg(sv *Server, msg *Message) {
if strings.HasPrefix(msg.Args[0], "#") {
clid := strings.ToLower(msg.Pre)
chid := strings.ToLower(msg.Args[0])
if sv.channelCheckMode(chid, "m") &&
!sv.channelCheckPerm(chid, clid, "ohv") {
sv.sendReply(clid, ERR_CANNOTSENDTOCHAN, chid, "Cannot send to channel")
return
}
if _, exists := sv.chUsers[chid][clid]; !exists {
sv.sendReply(clid, ERR_CANNOTSENDTOCHAN, chid, "Cannot send to channel")
return
}
}
sv.sendMsg(msg)
}
func handleCmdJoin(sv *Server, msg *Message) {
first := false
clid := strings.ToLower(msg.Pre)
chid := strings.ToLower(msg.Args[0])
if !strings.HasPrefix(chid, "#") {
sv.sendReply(msg.Pre, ERR_NOSUCHCHANNEL, msg.Args[0], "No such channel")
return
}
if _, exists := sv.chUsers[chid]; !exists {
sv.chUsers[chid] = make(map[string]string)
sv.chTopics[chid] = ""
sv.chModes[chid] = make(map[string]bool)
first = true
}
if _, exists := sv.chUsers[chid][clid]; exists {
return
}
sv.chUsers[chid][clid] = ""
sv.sendMsg(msg)
// dont proceed further if message was sent by remote origin
if !sv.localOrigin(msg) {
return
}
sv.cluster.Subscribe(chid, sv.remoteq)
sv.sendReply(msg.Pre, RPL_TOPIC, msg.Args[0], sv.chTopics[msg.Args[0]])
sv.channelNames(msg.Pre, msg.Args[0])
m, isoper := sv.opers[clid]
if isoper {
mode := "o " + clid
sv.chModes[chid][mode] = true
sv.sendMsg(M(sv.host, "MODE", chid+" +o "+clid, ""))
if m == "a" {
sv.sendMsg(M(sv.host, "PRIVMSG", chid, clid+" is a server administrator"))
}
if m == "o" {
sv.sendMsg(M(sv.host, "PRIVMSG", chid, clid+" is a server operator"))
}
return
}
if first {
mode := "o " + clid
sv.chModes[chid][mode] = true
sv.sendMsg(M(sv.host, "MODE", chid+" +o "+clid, ""))
}
}
// Handle user parting the channel and delete channel if last user has
// left
func handleCmdPart(sv *Server, msg *Message) {
clid := strings.ToLower(msg.Pre)
chid := strings.ToLower(msg.Args[0])
if _, exists := sv.chUsers[chid]; !exists {
return
}
if _, exists := sv.chUsers[chid][clid]; !exists {
return
}
sv.sendMsg(msg)
sv.channelRemoveUser(chid, clid)
}
func handleCmdQuit(sv *Server, msg *Message) {
}
func handleCmdMode(sv *Server, msg *Message) {
if strings.HasPrefix(msg.Args[0], "#") {
chid := strings.ToLower(msg.Args[0])
clid := strings.ToLower(msg.Pre)
if _, exists := sv.chUsers[chid]; !exists {
return
}
if len(msg.Args) < 2 {
return
}
mode := ""
modeSwitch := msg.Args[1]
modeTarget := ""
if len(modeSwitch) < 2 {
return
}
if len(msg.Args) > 2 {
modeTarget = strings.ToLower(msg.Args[2])
}
switch modeSwitch[1] {
// maybe this can be done more elegant
case 'o':
if !sv.channelCheckPerm(chid, clid, "o") {
goto noPerm
}
case 'h':
if !sv.channelCheckPerm(chid, clid, "o") {
goto noPerm
}
case 'b':
if !sv.channelCheckPerm(chid, clid, "oh") {
goto noPerm
}
case 'v':
if !sv.channelCheckPerm(chid, clid, "oh") {
goto noPerm
}
case 'm':
if !sv.channelCheckPerm(chid, clid, "oh") {
goto noPerm
}
case 't':
if !sv.channelCheckPerm(chid, clid, "oh") {
goto noPerm
}
default:
return
}
mode = string(modeSwitch[1])
if modeTarget != "" {
mode = mode + " " + modeTarget
}
if modeSwitch[0] == '+' {
sv.chModes[chid][mode] = true
} else {
delete(sv.chModes[chid], mode)
}
sv.sendMsg(msg)
return
noPerm:
sv.sendReply(clid, ERR_CHANOPRIVSNEEDED, chid, "You're not channel operator")
}
}
func handleCmdTopic(sv *Server, msg *Message) {
chid := strings.ToLower(msg.Args[0])
clid := strings.ToLower(msg.Pre)
if _, exists := sv.chUsers[chid]; !exists {
sv.sendReply(msg.Pre, ERR_NOSUCHCHANNEL, chid, "No such channel")
}
if msg.Trail == "" {
sv.sendReply(msg.Pre, RPL_TOPIC, chid, sv.chTopics[chid])
} else {
if sv.channelCheckMode(chid, "t") &&
!sv.channelCheckPerm(chid, clid, "oh") {
sv.sendReply(clid, ERR_CHANOPRIVSNEEDED, chid, "You're not channel operator")
return
}
sv.chTopics[chid] = msg.Trail
sv.sendMsg(msg)
//sv.sendReply(msg.Pre, RPL_TOPIC, ch, msg.Trail)
}
}
func handleCmdKick(sv *Server, msg *Message) {
chid := strings.ToLower(msg.Args[0])
clid := strings.ToLower(msg.Pre)
target := strings.ToLower(msg.Args[1])
if !sv.channelCheckPerm(chid, clid, "oh") {
sv.sendReply(clid, ERR_CHANOPRIVSNEEDED, chid, "You're not channel operator")
}
sv.sendMsg(msg)
sv.channelRemoveUser(chid, target)
}
func handleCmdNames(sv *Server, msg *Message) {
chid := strings.ToLower(msg.Args[0])
if _, exists := sv.chUsers[chid]; !exists {
sv.sendReply(msg.Pre, ERR_NOSUCHCHANNEL, chid, "No such channel")
}
sv.channelNames(msg.Pre, chid)
}
func handleCmdWho(sv *Server, msg *Message) {
clid := strings.ToLower(msg.Args[0])
if _, exists := sv.clients[clid]; exists {
sv.sendReply(msg.Pre, RPL_WHOREPLY,
fmt.Sprintf("* %s %s %s %s %s%s", clid, sv.clHosts[clid], sv.host, clid, "H", ""), "0 "+msg.Args[0])
}
sv.sendReply(msg.Pre, RPL_ENDOFWHO, clid, "End of /WHO list.")
}
func handleCmdWhois(sv *Server, msg *Message) {
clid := strings.ToLower(msg.Args[0])
if _, exists := sv.clients[clid]; !exists {
sv.sendReply(msg.Pre, ERR_NOSUCHNICK, clid, "No such nick")
return
}
sv.sendReply(msg.Pre, RPL_WHOISUSER, fmt.Sprintf("%s %s %s *", clid, clid, sv.clHosts[clid]), msg.Args[0])
m, isoper := sv.opers[clid]
if isoper {
if m == "a" {
sv.sendReply(msg.Pre, RPL_WHOISOPERATOR, clid, "is a server administrator")
}
if m == "o" {
sv.sendReply(msg.Pre, RPL_WHOISOPERATOR, clid, "is a server operator")
}
}
sv.sendReply(msg.Pre, RPL_ENDOFWHOIS, "", "End of /WHOIS list")
}
func handleCmdPing(sv *Server, msg *Message) {
sv.sendReply(msg.Pre, "PONG", msg.Args[0], "")
}
func handleCmdPong(sv *Server, msg *Message) {
}
func handleCmdRehash(sv *Server, msg *Message) {
sv.loadConfig()
sv.sendReply(msg.Pre, RPL_REHASHING, "", "Rehashing")
xlog.Info("Rehashing")
}
func handleCmdKill(sv *Server, msg *Message) {
}

70
irc/monitoring.go Normal file
View file

@ -0,0 +1,70 @@
// vim:ts=4:sts=4:sw=4:noet:tw=72
package irc
import (
"net/http"
"runtime"
"time"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/client_golang/prometheus/promhttp"
)
var (
gaugeGoroutinesRunning prometheus.Gauge
gaugePacketsTransferred prometheus.Gauge
gaugeConnectionsCurrent prometheus.Gauge
gaugeConnectionsCount prometheus.Gauge
gaugeLocalQueueLen prometheus.Gauge
gaugeRemoteQueueLen prometheus.Gauge
)
func monitoringRun(sv *Server) {
gaugeGoroutinesRunning = prometheus.NewGauge(prometheus.GaugeOpts{
Name: "ircd_goroutines_running",
Help: "Goroutines runnning",
})
gaugePacketsTransferred = prometheus.NewGauge(prometheus.GaugeOpts{
Name: "ircd_packets_transferred",
Help: "Packets handled",
})
gaugeConnectionsCurrent = prometheus.NewGauge(prometheus.GaugeOpts{
Name: "ircd_connections_current",
Help: "Client connections",
})
gaugeConnectionsCount = prometheus.NewGauge(prometheus.GaugeOpts{
Name: "ircd_connections_count",
Help: "Client connections",
})
gaugeLocalQueueLen = prometheus.NewGauge(prometheus.GaugeOpts{
Name: "ircd_local_queue_len",
Help: "Unhandled msgs in dispatcher local queue",
})
gaugeRemoteQueueLen = prometheus.NewGauge(prometheus.GaugeOpts{
Name: "ircd_remote_queue_len",
Help: "Unhandled msgs in dispatcher remote queue",
})
prometheus.MustRegister(gaugeGoroutinesRunning)
prometheus.MustRegister(gaugePacketsTransferred)
prometheus.MustRegister(gaugeConnectionsCurrent)
prometheus.MustRegister(gaugeConnectionsCount)
prometheus.MustRegister(gaugeLocalQueueLen)
prometheus.MustRegister(gaugeRemoteQueueLen)
go monitoringUpdater(sv)
http.Handle("/metrics", promhttp.Handler())
laddr, _ := sv.config.GetString("net", "listen_prom")
http.ListenAndServe(laddr, nil)
}
func monitoringUpdater(sv *Server) {
for {
time.Sleep(10 * time.Second)
gaugeGoroutinesRunning.Set(float64(runtime.NumGoroutine()))
gaugePacketsTransferred.Set(sv.packetsTransferred)
gaugeConnectionsCurrent.Set(float64(len(sv.clients)))
gaugeConnectionsCount.Set(sv.connectionsCount)
gaugeLocalQueueLen.Set(float64(len(sv.localq)))
gaugeRemoteQueueLen.Set(float64(len(sv.remoteq)))
}
}

273
irc/protocol.go Normal file
View file

@ -0,0 +1,273 @@
package irc
import (
"fmt"
"strings"
)
const (
// Commands
CMD_ADMIN = "ADMIN"
CMD_AWAY = "AWAY"
CMD_CLEARCHAN = "CLEARCHAN"
CMD_CLEAROPS = "CLEAROPS"
CMD_DIE = "DIE"
CMD_ERROR = "ERROR"
CMD_HELP = "HELP"
CMD_INFO = "INFO"
CMD_INVITE = "INVITE"
CMD_ISON = "ISON"
CMD_JOIN = "JOIN"
CMD_KICK = "KICK"
CMD_KILL = "KILL"
CMD_KLINE = "KLINE"
CMD_LIST = "LIST"
CMD_MODE = "MODE"
CMD_NAMES = "NAMES"
CMD_NICK = "NICK"
CMD_NOTICE = "NOTICE"
CMD_OJOIN = "OJOIN"
CMD_OPER = "OPER"
CMD_OPME = "OPME"
CMD_PART = "PART"
CMD_PASS = "PASS"
CMD_PING = "PING"
CMD_PONG = "PONG"
CMD_PRIVMSG = "PRIVMSG"
CMD_QUIT = "QUIT"
CMD_REHASH = "REHASH"
CMD_RESTART = "RESTART"
CMD_SERVER = "SERVER"
CMD_STATS = "STATS"
CMD_SUMMON = "SUMMON"
CMD_SQUIT = "SQUIT"
CMD_TIME = "TIME"
CMD_TOPIC = "TOPIC"
CMD_USER = "USER"
CMD_USERHOST = "USERHOST"
CMD_USERS = "USERS"
CMD_VERSION = "VERSION"
CMD_WALLOPS = "WALLOPS"
CMD_WHO = "WHO"
CMD_WHOIS = "WHOIS"
CMD_WHOWAS = "WHOWAS"
// Signon responses
RPL_WELCOME = "001"
RPL_YOURHOST = "002"
RPL_CREATED = "003"
RPL_MYINFO = "004"
RPL_ISUPPORT = "005"
// Command replies
RPL_ADMINEMAIL = "259"
RPL_ADMINLOC1 = "257"
RPL_ADMINLOC2 = "258"
RPL_ADMINME = "256"
RPL_AWAY = "301"
RPL_BANLIST = "367"
RPL_CHANNELMODEIS = "324"
RPL_ENDOFBANLIST = "368"
RPL_ENDOFEXCEPTLIST = "349"
RPL_ENDOFINFO = "374"
RPL_ENDOFINVITELIST = "347"
RPL_ENDOFLINKS = "365"
RPL_ENDOFMOTD = "376"
RPL_ENDOFNAMES = "366"
RPL_ENDOFSTATS = "219"
RPL_ENDOFUSERS = "394"
RPL_ENDOFWHO = "315"
RPL_ENDOFWHOIS = "318"
RPL_EXCEPTLIST = "348"
RPL_INFO = "371"
RPL_INVITELIST = "346"
RPL_INVITING = "341"
RPL_ISON = "303"
RPL_LINKS = "364"
RPL_LISTSTART = "321"
RPL_LIST = "322"
RPL_LISTEND = "323"
RPL_LUSERCHANNELS = "254"
RPL_LUSERCLIENT = "251"
RPL_LUSERME = "255"
RPL_LUSEROP = "252"
RPL_LUSERUNKNOWN = "253"
RPL_MOTD = "372"
RPL_MOTDSTART = "375"
RPL_NAMEREPLY = "353"
RPL_NOTOPIC = "331"
RPL_NOUSERS = "395"
RPL_NOWAWAY = "306"
RPL_REHASHING = "382"
RPL_SERVLIST = "234"
RPL_SERVLISTEND = "235"
RPL_STATSCOMMANDS = "212"
RPL_STATSLINKINFO = "211"
RPL_STATSOLINE = "243"
RPL_STATSpLINE = "249"
RPL_STATSPLINE = "220"
RPL_STATSUPTIME = "242"
RPL_SUMMONING = "342"
RPL_TIME = "391"
RPL_TOPIC = "332"
RPL_TOPICWHOTIME = "333"
RPL_TRACECLASS = "209"
RPL_TRACECONNECTING = "201"
RPL_TRACEEND = "262"
RPL_TRACEHANDSHAKE = "202"
RPL_TRACELINK = "200"
RPL_TRACELOG = "261"
RPL_TRACENEWTYPE = "208"
RPL_TRACEOPERATOR = "204"
RPL_TRACERECONNECT = "210"
RPL_TRACESERVER = "206"
RPL_TRACESERVICE = "207"
RPL_TRACEUNKNOWN = "203"
RPL_TRACEUSER = "205"
RPL_TRYAGAIN = "263"
RPL_UMODEIS = "221"
RPL_UNAWAY = "305"
RPL_UNIQOPIS = "325"
RPL_USERHOST = "302"
RPL_USERS = "393"
RPL_USERSSTART = "392"
RPL_VERSION = "351"
RPL_WHOISACCOUNT = "330"
RPL_WHOISCHANNELS = "319"
RPL_WHOISHOST = "378"
RPL_WHOISIDLE = "317"
RPL_WHOISMODES = "379"
RPL_WHOISOPERATOR = "313"
RPL_WHOISSECURE = "671"
RPL_WHOISSERVER = "312"
RPL_WHOISUSER = "311"
RPL_WHOREPLY = "352"
RPL_YOUREOPER = "381"
RPL_YOURESERVICE = "383"
// Error replies
ERR_ALREADYREGISTERED = "462"
ERR_BADCHANMASK = "476"
ERR_BADCHANNELKEY = "475"
ERR_BADMASK = "415"
ERR_BANLISTFULL = "478"
ERR_BANNEDFROMCHAN = "474"
ERR_CANNOTSENDTOCHAN = "404"
ERR_CANTKILLSERVER = "483"
ERR_CHANNELISFULL = "471"
ERR_CHANOPRIVSNEEDED = "482"
ERR_ERRONEOUSNICKNAME = "432"
ERR_FILEERROR = "424"
ERR_INVITEONLYCHAN = "473"
ERR_KEYSET = "467"
ERR_NEEDMOREPARAMS = "461"
ERR_NICKCOLLISION = "436"
ERR_NICKNAMEINUSE = "433"
ERR_NOADMININFO = "423"
ERR_NOCHANMODES = "477"
ERR_NOLOGIN = "444"
ERR_NOMOTD = "422"
ERR_NONICKNAMEGIVEN = "431"
ERR_NOOPERHOST = "491"
ERR_NOORIGIN = "409"
ERR_NOPERMFORHOST = "463"
ERR_NOPRIVILEGES = "481"
ERR_NORECIPIENT = "411"
ERR_NOSUCHCHANNEL = "403"
ERR_NOSUCHNICK = "401"
ERR_NOSUCHSERVER = "402"
ERR_NOSUCHSERVICE = "408"
ERR_NOTEXTTOSEND = "412"
ERR_NOTONCHANNEL = "442"
ERR_NOTOPLEVEL = "413"
ERR_NOTREGISTERED = "451"
ERR_PASSWDMISMATCH = "464"
ERR_RESTRICTED = "484"
ERR_SUMMONDISABLED = "445"
ERR_TOOMANYCHANNELS = "405"
ERR_TOOMANYTARGETS = "407"
ERR_UMODEUNKNOWNFLAG = "501"
ERR_UNAVAILRESOURCE = "437"
ERR_UNIQOPPRIVSNEEDED = "485"
ERR_UNKNOWNCOMMAND = "421"
ERR_UNKNOWNMODE = "472"
ERR_USERNOTINCHANNEL = "441"
ERR_USERONCHANNEL = "443"
ERR_USERSDISABLED = "446"
ERR_USERSDONTMATCH = "502"
ERR_WASNOSUCHNICK = "406"
ERR_WILDTOPLEVEL = "414"
ERR_YOUREBANNEDCREEP = "465"
ERR_YOUWILLBEBANNED = "466"
// Custom numerics
RPL_HELPSTART = "704" // Sent at start of HELP response
RPL_HELPTXT = "705" // Sent for lines of HELP response
RPL_ENDOFHELP = "706" // Sent at end of HELP response
RPL_STATSMEMMEM = "710" // STATS reply for "mem" - Memory statistics
RPL_STATSMEMHEAP = "711" // STATS reply for "mem" - Heap statistics
RPL_STATSMEMRTIME = "712" // STATS reply for "mem" - Runtime statistics
// Custom errors
ERR_BANONCHAN = "435" // Cannot change nickname while banned on channel
ERR_UNKNOWNSTAT = "910" // STATS error for unknown STAT request
)
type Message struct {
Pre, Cmd, Trail, Raw string
Args []string
}
func M(pre, cmd, args, trail string) *Message {
argv := []string{}
if args != "" {
argv = strings.Split(args, " ")
}
return &Message{Pre: pre, Cmd: cmd, Args: argv, Trail: trail}
}
func Parse(raw string) *Message {
var i int
pre, cmd, trail := "", "", ""
args := []string{}
s := raw
if strings.HasPrefix(s, ":") {
i = strings.Index(s, " ")
pre = s[1:i]
if i+1 < len(s) {
s = s[i+1:]
}
} else {
pre = ""
}
i = strings.Index(s, " ")
if i != -1 {
cmd = s[0:i]
if i+1 < len(s) {
s = s[i+1:]
}
} else {
cmd = s
}
i = strings.Index(s, ":")
if i != -1 {
if i+1 < len(s) {
trail = s[i+1:]
if i > 2 {
s = s[0 : i-1]
} else {
s = ""
}
}
}
args = strings.Split(s, " ")
return &Message{Pre: pre, Cmd: cmd, Args: args, Trail: trail, Raw: raw}
}
func (m *Message) String() string {
args := ""
for _, arg := range m.Args {
args += " " + arg
}
if m.Trail != "" {
return fmt.Sprintf(":%s %s%s :%s", m.Pre, m.Cmd, args, strings.Replace(m.Trail, "%", "%%", -1))
}
return fmt.Sprintf(":%s %s%s", m.Pre, m.Cmd, args)
}

474
irc/server.go Normal file
View file

@ -0,0 +1,474 @@
// vim:ts=4:sts=4:sw=4:noet:tw=72
package irc
import (
"crypto/rand"
"crypto/tls"
"fmt"
"net"
"os"
"strings"
"time"
"git.dnix.de/an/conf"
"git.dnix.de/an/xlog"
)
const (
CHANLIMIT = 1024
CHANNELLEN = 200
TOPICLEN = 1024
)
var myinfo string = "%s %s/%s * *"
var isupport string = "CASEMAPPING=rfc1459 CHANTYPES=# NICKLEN=32 MODES=1 PREFIX=(ohv)@%+"
type Server struct {
localq chan *Message
remoteq chan *Message
addq chan Client
delq chan Client
host string
info string
software string
version string
created string
motd string
cluster *ClusterConnector
opers map[string]string
clients map[string]Client
clModes map[string]string
clHosts map[string]string
services map[string]*Service
chUsers map[string]map[string]string
chTopics map[string]string
chModes map[string]map[string]bool
config *conf.ConfigFile
configPath string
packetsTransferred float64
connectionsCount float64
authCallback func(name, pass string) (string, bool)
}
func NewServer(configPath, software, version string) *Server {
sv := &Server{software: software, version: version,
created: time.Now().String()}
sv.localq = make(chan *Message, 65536)
sv.remoteq = make(chan *Message, 65536)
sv.addq = make(chan Client, 128)
sv.delq = make(chan Client, 128)
sv.opers = make(map[string]string)
sv.clients = make(map[string]Client)
sv.clModes = make(map[string]string)
sv.clHosts = make(map[string]string)
sv.services = make(map[string]*Service, 0)
sv.chUsers = make(map[string]map[string]string)
sv.chTopics = make(map[string]string)
sv.chModes = make(map[string]map[string]bool)
sv.configPath = configPath
sv.loadConfig()
loglevel, _ := sv.config.GetInt("system", "loglevel")
xlog.Init(loglevel)
sv.host, _ = sv.config.GetString("server", "host")
sv.info, _ = sv.config.GetString("server", "info")
sv.motd, _ = sv.config.GetString("server", "motd")
urls, _ := sv.config.GetString("cluster", "urls")
sv.cluster = NewClusterConnector(urls, false)
nicks, _ := sv.config.GetString("control", "a")
for _, nick := range strings.Split(nicks, ",") {
sv.opers[strings.ToLower(nick)] = "a"
}
nicks, _ = sv.config.GetString("control", "o")
for _, nick := range strings.Split(nicks, ",") {
sv.opers[strings.ToLower(nick)] = "o"
}
sv.packetsTransferred = 0
sv.connectionsCount = 0
return sv
}
func (sv *Server) SetAuthCallback(authCB func(name, pass string) (string, bool)) {
sv.authCallback = authCB
}
func (sv *Server) Run() {
xlog.Info("%s/%s", sv.software, sv.version)
go monitoringRun(sv)
laddr, err := sv.config.GetString("net", "listen")
if err == nil {
go sv.listen(laddr)
}
tls := true
pem, err := sv.config.GetString("tls", "pem")
if err != nil {
tls = false
}
key, err := sv.config.GetString("tls", "key")
if err != nil {
tls = false
}
laddr, err = sv.config.GetString("net", "listen_tls")
if err == nil && tls {
go sv.listenTls(laddr, pem, key)
}
for {
err = sv.dispatcher()
if err != nil {
xlog.Error("Dispatcher in panic: %s", err.Error())
}
}
}
func (sv *Server) Dispatch(msg *Message) {
sv.localq <- msg
}
func (sv *Server) AddClient(cl Client) {
sv.addq <- cl
}
func (sv *Server) DelClient(cl Client) {
sv.delq <- cl
}
func (sv *Server) LinkService(name string, svc *Service) {
sv.services[name] = svc
svc.Run()
}
func (sv *Server) UnlinkService(name string) {
sv.services[name].Stop()
delete(sv.services, name)
}
func (sv *Server) listen(laddr string) {
listen, err := net.Listen("tcp", laddr)
if err != nil {
xlog.Fatal(err.Error())
os.Exit(-1)
}
for {
time.Sleep(10 * time.Millisecond)
conn, err := listen.Accept()
if err != nil {
xlog.Error(err.Error())
} else {
NewRemoteClient(sv, conn)
sv.connectionsCount++
}
}
}
func (sv *Server) listenTls(laddr, pem, key string) {
cert, err := tls.LoadX509KeyPair(pem, key)
if err != nil {
xlog.Fatal(err.Error())
}
cfg := tls.Config{Certificates: []tls.Certificate{cert}}
cfg.Rand = rand.Reader
listen, err := tls.Listen("tcp", laddr, &cfg)
if err != nil {
xlog.Fatal(err.Error())
}
for {
time.Sleep(10 * time.Millisecond)
conn, err := listen.Accept()
if err != nil {
xlog.Error(err.Error())
} else {
NewRemoteClient(sv, conn)
sv.connectionsCount++
}
}
}
func (sv *Server) dispatcher() (err error) {
defer func() {
if r := recover(); r != nil {
var ok bool
err, ok = r.(error)
if !ok {
err = fmt.Errorf("pkg: %v", r)
}
}
}()
for {
select {
case msg := <-sv.localq:
sv.recvMsg(msg)
sv.packetsTransferred++
case msg := <-sv.remoteq:
if sv.localOrigin(msg) {
continue
}
sv.recvMsg(msg)
sv.packetsTransferred++
case cl := <-sv.addq:
sv.addClient(cl)
case cl := <-sv.delq:
sv.delClient(cl)
default:
time.Sleep(10 * time.Millisecond)
}
}
return
}
func (sv *Server) loadConfig() {
cfg, err := conf.ReadConfigFile(sv.configPath)
if err != nil {
xlog.Fatal("Can't read config file (%s)", err.Error())
os.Exit(-1)
}
sv.config = cfg
}
func (sv *Server) addClient(cl Client) {
clid := strings.ToLower(cl.Name())
if _, exists := sv.clients[clid]; exists {
cl.Receive(M(sv.host, ERR_NICKNAMEINUSE, cl.Name(), "Nickname is already in use"))
go func() {
time.Sleep(5 * time.Second)
cl.Register(false)
}()
xlog.Info("Client registration failed: '%s' (client exists)", clid)
return
}
if host, success := sv.authCallback(cl.Name(), cl.Password()); success {
sv.clients[clid] = cl
sv.clHosts[clid] = host
sv.sendLogon(cl.Name())
cl.Register(true)
sv.cluster.Subscribe(clid, sv.remoteq)
xlog.Info("Client registered: '%s'", clid)
xlog.Info("Server has %d client(s)", len(sv.clients))
} else {
cl.Receive(M(sv.host, ERR_PASSWDMISMATCH, "", "Password incorrect"))
go func() {
time.Sleep(5 * time.Second)
cl.Register(false)
}()
xlog.Info("Client registration failed: '%s' (wrong password)", clid)
return
}
}
func (sv *Server) delClient(cl Client) {
clid := strings.ToLower(cl.Name())
sv.cluster.Unsubscribe(clid)
cl.Destroy()
for chid, _ := range sv.chUsers {
if _, exists := sv.chUsers[chid][clid]; exists {
sv.channelRemoveUser(chid, clid)
sv.sendMsg(M(cl.Name(), "PART", chid, "quit"))
}
}
delete(sv.clients, clid)
xlog.Info("Client deleted: '%s'", clid)
xlog.Info("Server has %d client(s)", len(sv.clients))
}
func (sv *Server) recvMsg(msg *Message) {
cmd := msg.Cmd
clid := strings.ToLower(msg.Pre)
hook, exists := svCommandHooks[cmd]
if !exists {
sv.sendReply(msg.Pre, ERR_UNKNOWNCOMMAND, cmd, "Unknown command")
return
}
nm := hook.NeedMode
if nm != "" {
if m, isoper := sv.opers[clid]; !isoper {
sv.sendReply(msg.Pre, ERR_NOPRIVILEGES, cmd, "Permission denied: You're not a server operator")
return
} else {
if strings.Index(nm, m) == -1 {
sv.sendReply(msg.Pre, ERR_NOPRIVILEGES, cmd, "Permission denied: You're not a server admin")
return
}
}
}
argc := len(msg.Args)
if argc < hook.MinArgs {
sv.sendReply(msg.Pre, ERR_NEEDMOREPARAMS, cmd, "Not enough parameters")
return
}
if hook.NeedTrail && msg.Trail == "" {
sv.sendReply(msg.Pre, ERR_NEEDMOREPARAMS, cmd, "Not enough parameters")
return
}
hook.HookFn(sv, msg)
}
func (sv *Server) sendMsg(msg *Message) {
sv.deliverMsg(msg)
sv.forwardMsg(msg)
}
func (sv *Server) deliverMsg(msg *Message) {
if strings.HasPrefix(msg.Args[0], "#") {
chid := strings.ToLower(msg.Args[0])
if _, exists := sv.chUsers[chid]; !exists {
sv.sendReply(msg.Pre, ERR_NOSUCHNICK, msg.Args[0], "No such nick/channel")
return
}
for clid, _ := range sv.chUsers[chid] {
if strings.ToLower(msg.Pre) == clid && msg.Cmd == "PRIVMSG" {
continue
}
if cl, exists := sv.clients[clid]; exists {
cl.Receive(msg)
}
}
} else {
clid := strings.ToLower(msg.Args[0])
if _, exists := sv.clients[clid]; !exists {
sv.sendReply(msg.Pre, ERR_NOSUCHNICK, msg.Args[0], "No such nick/channel")
return
}
cl := sv.clients[clid]
cl.Receive(msg)
}
}
func (sv *Server) forwardMsg(msg *Message) {
if sv.localOrigin(msg) {
sv.cluster.Publish(msg)
}
}
func (sv *Server) sendReply(nick, cmd, args, trail string) {
clid := strings.ToLower(nick)
if _, exists := sv.clients[clid]; !exists {
return
}
cl := sv.clients[clid]
if args != "" {
args = nick + " " + args
} else {
args = nick
}
cl.Receive(M(sv.host, cmd, args, trail))
}
func (sv *Server) localOrigin(msg *Message) bool {
_, localClient := sv.clients[strings.ToLower(msg.Pre)]
localServer := (msg.Pre == sv.host)
return localClient || localServer
}
func (sv *Server) sendLogon(nick string) {
sv.sendReply(nick, RPL_WELCOME, "", "Willkommen!")
sv.sendReply(nick, RPL_YOURHOST, "",
fmt.Sprintf("Your host is %s, running on %s/%s",
sv.host, sv.software, sv.version))
sv.sendReply(nick, RPL_CREATED, "",
fmt.Sprintf("This server was created %s", sv.created))
sv.sendReply(nick, RPL_MYINFO, "",
fmt.Sprintf(myinfo, sv.host, sv.software, sv.version))
sv.sendReply(nick, RPL_ISUPPORT, "",
isupport+" are supported by this server")
sv.sendReply(nick, RPL_MOTDSTART, "",
fmt.Sprintf("- %s Message of the day -", sv.host))
for _, line := range strings.Split(sv.motd, "\n") {
sv.sendReply(nick, RPL_MOTD, "", fmt.Sprintf("- %s", line))
}
sv.sendReply(nick, RPL_ENDOFMOTD, "", "End of MOTD command")
if m, isoper := sv.opers[strings.ToLower(nick)]; isoper {
switch m {
case "a":
sv.sendReply(nick, RPL_YOUREOPER, "", "You are now a server admin")
case "o":
sv.sendReply(nick, RPL_YOUREOPER, "", "You are now a server operator")
}
}
}
func (sv *Server) channelNames(nick, ch string) {
chid := strings.ToLower(ch)
if _, exists := sv.chUsers[chid]; !exists {
return
}
names := ""
for clid, _ := range sv.chUsers[chid] {
name := sv.clients[clid].Name()
if names != "" {
names += " "
}
modeFlags := "ohv"
modeChars := "@%+"
for i, mf := range modeFlags {
if _, exists := sv.chModes[chid][string(mf)+" "+clid]; exists {
name = string(modeChars[i]) + name
break
}
}
names = names + name
}
chunks := len(strings.Split(names, " "))/8 + 1
nameList := strings.SplitN(names, " ", chunks)
for _, nameSlice := range nameList {
sv.sendReply(nick, RPL_NAMEREPLY, "= "+ch, nameSlice)
}
sv.sendReply(nick, RPL_ENDOFNAMES, ch, "End of /NAMES list")
}
func (sv *Server) channelCheckMode(chid, mode string) bool {
if _, exists := sv.chModes[chid]; !exists {
return false
}
if _, exists := sv.chModes[chid][mode]; !exists {
return false
}
return true
}
func (sv *Server) channelCheckPerm(chid, clid, modes string) bool {
for _, m := range modes {
if sv.channelCheckMode(chid, string(m)+" "+clid) {
return true
}
}
return false
}
func (sv *Server) channelRemoveUser(chid, clid string) {
if _, exists := sv.chUsers[chid]; !exists {
return
}
delete(sv.chUsers[chid], clid)
delete(sv.chModes[chid], "o "+clid)
delete(sv.chModes[chid], "h "+clid)
delete(sv.chModes[chid], "v "+clid)
if len(sv.chUsers[chid]) == 0 {
sv.cluster.Unsubscribe(chid)
delete(sv.chUsers, chid)
delete(sv.chTopics, chid)
delete(sv.chModes, chid)
}
}

47
irc/service.go Normal file
View file

@ -0,0 +1,47 @@
// vim:ts=4:sts=4:sw=4:noet:tw=72
package irc
import (
"time"
)
type Service struct {
recvq chan *Message
handlers map[string]func(*Message)
}
func NewService() *Service {
recvq := make(chan *Message, 1024)
handlers := make(map[string]func(*Message))
return &Service{recvq: recvq, handlers: handlers}
}
func (svc *Service) Run() {
go svc.dispatcher()
}
func (svc *Service) Stop() {
}
func (svc *Service) Dispatch(msg *Message) {
svc.recvq <- msg
}
func (svc *Service) Handler(cmd string, fn func(*Message)) {
svc.handlers[cmd] = fn
}
func (svc *Service) dispatcher() {
for {
time.Sleep(10 * time.Millisecond)
select {
case msg := <-svc.recvq:
if fn, exists := svc.handlers[msg.Pre]; exists {
fn(msg)
}
default:
}
}
return
}