summaryrefslogtreecommitdiff
path: root/xS/main.go
diff options
context:
space:
mode:
Diffstat (limited to 'xS/main.go')
-rw-r--r--xS/main.go520
1 files changed, 486 insertions, 34 deletions
diff --git a/xS/main.go b/xS/main.go
index 98a8b3b..75f4231 100644
--- a/xS/main.go
+++ b/xS/main.go
@@ -201,7 +201,7 @@ func readConfigFile(name string, output interface{}) error {
// --- Rate limiter ------------------------------------------------------------
type floodDetector struct {
- interval uint // interval for the limit
+ interval uint // interval for the limit in seconds
limit uint // maximum number of events allowed
timestamps []int64 // timestamps of last events
pos uint // index of the oldest event
@@ -217,7 +217,7 @@ func newFloodDetector(interval, limit uint) *floodDetector {
}
func (fd *floodDetector) check() bool {
- now := time.Now().Unix()
+ now := time.Now().UnixNano()
fd.timestamps[fd.pos] = now
fd.pos++
@@ -226,7 +226,7 @@ func (fd *floodDetector) check() bool {
}
var count uint
- begin := now - int64(fd.interval)
+ begin := now - int64(time.Second)*int64(fd.interval)
for _, ts := range fd.timestamps {
if ts >= begin {
count++
@@ -471,12 +471,11 @@ func newWhowasInfo(c *client) *whowasInfo {
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
type ircCommand struct {
- name string
requiresRegistration bool
handler func(*message, *client)
nReceived uint // number of commands received
- bytesReceived uint // number of bytes received total
+ bytesReceived int // number of bytes received total
}
type preparedEvent struct {
@@ -563,39 +562,29 @@ func ircChannelDestroyIfEmpty(ch *channel) {
// TODO
}
-// TODO: ircSendToRoommates
-// Broadcast to all /other/ clients (telnet-friendly, also in accordance to
-// the plan of extending this to an IRCd).
-func broadcast(line string, except *client) {
- for c := range clients {
- if c != except {
- c.send(line)
- }
- }
-}
-
func ircSendToRoommates(c *client, message string) {
// TODO
}
// --- Clients (continued) -----------------------------------------------------
-func clientModeToString(m uint, mode *[]byte) {
+func ircAppendClientModes(m uint, mode []byte) []byte {
if 0 != m&ircUserModeInvisible {
- *mode = append(*mode, 'i')
+ mode = append(mode, 'i')
}
if 0 != m&ircUserModeRxWallops {
- *mode = append(*mode, 'w')
+ mode = append(mode, 'w')
}
if 0 != m&ircUserModeRestricted {
- *mode = append(*mode, 'r')
+ mode = append(mode, 'r')
}
if 0 != m&ircUserModeOperator {
- *mode = append(*mode, 'o')
+ mode = append(mode, 'o')
}
if 0 != m&ircUserModeRxServerNotices {
- *mode = append(*mode, 's')
+ mode = append(mode, 's')
}
+ return mode
}
func (c *client) getMode() string {
@@ -603,8 +592,7 @@ func (c *client) getMode() string {
if c.awayMessage != "" {
mode = append(mode, 'a')
}
- clientModeToString(c.mode, &mode)
- return string(mode)
+ return string(ircAppendClientModes(c.mode, mode))
}
func (c *client) send(line string) {
@@ -1215,15 +1203,15 @@ func ircHandleVERSION(msg *message, c *client) {
c.sendISUPPORT()
}
-/*
func ircChannelMulticast(ch *channel, msg string, except *client) {
- for c, m := range ch.userModes {
+ for c := range ch.userModes {
if c != except {
c.send(msg)
}
}
}
+/*
func ircModifyMode(mask *uint, mode uint, add bool) bool {
orig := *mask
if add {
@@ -1271,21 +1259,484 @@ func ircHandleUserMessage(msg *message, c *client,
}
target, text := msg.params[0], msg.params[1]
- if client, ok := users[ircToCanon(target)]; ok {
- // TODO
- _ = client
- _ = text
- } else if ch, ok := channels[ircToCanon(target)]; ok {
- // TODO
- _ = ch
+ message := fmt.Sprintf(":%s!%s@%s %s %s :%s",
+ c.nickname, c.username, c.hostname, command, target, text)
+
+ if client := users[ircToCanon(target)]; client != nil {
+ client.send(message)
+ if allowAwayReply && client.awayMessage != "" {
+ c.sendReply(RPL_AWAY, target, client.awayMessage)
+ }
+
+ // Acknowledging a message from the client to itself would be silly.
+ if client != c && (0 != c.capsEnabled&ircCapEchoMessage) {
+ c.send(message)
+ }
+ } else if ch := channels[ircToCanon(target)]; ch != nil {
+ modes, present := ch.userModes[c]
+
+ outsider := !present && 0 != ch.modes&ircChanModeNoOutsideMsgs
+ moderated := 0 != ch.modes&ircChanModeModerated &&
+ 0 == modes&(ircChanModeVoice|ircChanModeOperator)
+ banned := c.inMaskList(ch.banList) && !c.inMaskList(ch.exceptionList)
+
+ if outsider || moderated || banned {
+ c.sendReply(ERR_CANNOTSENDTOCHAN, target)
+ return
+ }
+
+ except := c
+ if 0 != c.capsEnabled&ircCapEchoMessage {
+ except = nil
+ }
+
+ ircChannelMulticast(ch, message, except)
} else {
c.sendReply(ERR_NOSUCHNICK, target)
}
}
+func ircHandlePRIVMSG(msg *message, c *client) {
+ ircHandleUserMessage(msg, c, "PRIVMSG", true /* allowAwayReply */)
+ // Let's not care too much about success or failure.
+ c.lastActive = time.Now().UnixNano()
+}
+
+func ircHandleNOTICE(msg *message, c *client) {
+ ircHandleUserMessage(msg, c, "NOTICE", false /* allowAwayReply */)
+}
+
+func ircHandleLIST(msg *message, c *client) {
+ if len(msg.params) > 1 && !isThisMe(msg.params[1]) {
+ c.sendReply(ERR_NOSUCHSERVER, msg.params[1])
+ return
+ }
+
+ // XXX: Maybe we should skip ircUserModeInvisible from user counts.
+ if len(msg.params) == 0 {
+ for _, ch := range channels {
+ if _, present := ch.userModes[c]; present ||
+ 0 == ch.modes&(ircChanModePrivate|ircChanModeSecret) {
+ c.sendReply(RPL_LIST, ch.name, len(ch.userModes), ch.topic)
+ }
+ }
+ } else {
+ for _, target := range splitString(msg.params[0], ",", true) {
+ if ch := channels[ircToCanon(target)]; ch != nil &&
+ 0 == ch.modes&ircChanModeSecret {
+ c.sendReply(RPL_LIST, ch.name, len(ch.userModes), ch.topic)
+ }
+ }
+ }
+ c.sendReply(RPL_LISTEND)
+}
+
+func ircAppendPrefixes(c *client, modes uint, buf []byte) []byte {
+ var all []byte
+ if 0 != modes&ircChanModeOperator {
+ all = append(all, '@')
+ }
+ if 0 != modes&ircChanModeVoice {
+ all = append(all, '+')
+ }
+
+ if len(all) > 0 {
+ if 0 != c.capsEnabled&ircCapMultiPrefix {
+ buf = append(buf, all...)
+ } else {
+ buf = append(buf, all[0])
+ }
+ }
+ return buf
+}
+
+func ircMakeRPLNAMREPLYItem(c, target *client, modes uint) string {
+ result := string(ircAppendPrefixes(c, modes, nil)) + target.nickname
+ if 0 != c.capsEnabled&ircCapUserhostInNames {
+ result += fmt.Sprintf("!%s@%s", target.username, target.hostname)
+ }
+ return result
+}
+
+// TODO: Consider using *client instead of string as the map key.
+func ircSendRPLNAMREPLY(c *client, ch *channel, usedNicks map[string]bool) {
+ kind := '='
+ if 0 != ch.modes&ircChanModeSecret {
+ kind = '@'
+ } else if 0 != ch.modes&ircChanModePrivate {
+ kind = '*'
+ }
+
+ _, present := ch.userModes[c]
+
+ var nicks []string
+ for client, modes := range ch.userModes {
+ if !present && 0 != client.mode&ircUserModeInvisible {
+ continue
+ }
+ if usedNicks != nil {
+ usedNicks[ircToCanon(client.nickname)] = true
+ }
+ nicks = append(nicks, ircMakeRPLNAMREPLYItem(c, client, modes))
+ }
+ c.sendReplyVector(RPL_NAMREPLY, nicks, kind, ch.name, "")
+}
+
+func ircSendDisassociatedNames(c *client, usedNicks map[string]bool) {
+ var nicks []string
+ for canonNickname, client := range users {
+ if 0 == client.mode&ircUserModeInvisible && !usedNicks[canonNickname] {
+ nicks = append(nicks, ircMakeRPLNAMREPLYItem(c, client, 0))
+ }
+ }
+ if len(nicks) > 0 {
+ c.sendReplyVector(RPL_NAMREPLY, nicks, '*', "*", "")
+ }
+}
+
+func ircHandleNAMES(msg *message, c *client) {
+ if len(msg.params) > 1 && !isThisMe(msg.params[1]) {
+ c.sendReply(ERR_NOSUCHSERVER, msg.params[1])
+ return
+ }
+
+ if len(msg.params) == 0 {
+ usedNicks := make(map[string]bool)
+
+ for _, ch := range channels {
+ if _, present := ch.userModes[c]; present ||
+ 0 == ch.modes&(ircChanModePrivate|ircChanModeSecret) {
+ ircSendRPLNAMREPLY(c, ch, usedNicks)
+ }
+ }
+
+ // Also send all visible users we haven't listed yet.
+ ircSendDisassociatedNames(c, usedNicks)
+ c.sendReply(RPL_ENDOFNAMES, "*")
+ } else {
+ for _, target := range splitString(msg.params[0], ",", true) {
+ if ch := channels[ircToCanon(target)]; ch == nil {
+ } else if _, present := ch.userModes[c]; present ||
+ 0 == ch.modes&ircChanModeSecret {
+ ircSendRPLNAMREPLY(c, ch, nil)
+ c.sendReply(RPL_ENDOFNAMES, target)
+ }
+ }
+ }
+}
+
+func ircSendRPLWHOREPLY(c *client, ch *channel, target *client) {
+ var chars []byte
+ if target.awayMessage != "" {
+ chars = append(chars, 'G')
+ } else {
+ chars = append(chars, 'H')
+ }
+
+ if 0 != target.mode&ircUserModeOperator {
+ chars = append(chars, '*')
+ }
+
+ channelName := "*"
+ if ch != nil {
+ channelName = ch.name
+ if modes, present := ch.userModes[target]; present {
+ chars = ircAppendPrefixes(c, modes, chars)
+ }
+ }
+
+ c.sendReply(RPL_WHOREPLY, channelName,
+ target.username, target.hostname, serverName,
+ target.nickname, string(chars), 0 /* hop count */, target.realname)
+}
+
+func ircMatchSendRPLWHOREPLY(c, target *client, mask string) {
+ isRoommate := false
+ for _, ch := range channels {
+ _, presentClient := ch.userModes[c]
+ _, presentTarget := ch.userModes[target]
+ if presentClient && presentTarget {
+ isRoommate = true
+ break
+ }
+ }
+ if !isRoommate && 0 != target.mode&ircUserModeInvisible {
+ return
+ }
+
+ if !ircFnmatch(mask, target.hostname) &&
+ !ircFnmatch(mask, target.nickname) &&
+ !ircFnmatch(mask, target.realname) &&
+ !ircFnmatch(mask, serverName) {
+ return
+ }
+
+ // Try to find a channel they're on that's visible to us.
+ var userCh *channel
+ for _, ch := range channels {
+ _, presentClient := ch.userModes[c]
+ _, presentTarget := ch.userModes[target]
+ if presentTarget && (presentClient ||
+ 0 == ch.modes&(ircChanModePrivate|ircChanModeSecret)) {
+ userCh = ch
+ break
+ }
+ }
+ ircSendRPLWHOREPLY(c, userCh, target)
+}
+
+func ircHandleWHO(msg *message, c *client) {
+ onlyOps := len(msg.params) > 1 && msg.params[1] == "o"
+
+ shownMask, usedMask := "*", "*"
+ if len(msg.params) > 0 {
+ shownMask = msg.params[0]
+ if shownMask != "0" {
+ usedMask = shownMask
+ }
+ }
+
+ if ch := channels[ircToCanon(usedMask)]; ch != nil {
+ _, present := ch.userModes[c]
+ if present || 0 == ch.modes&ircChanModeSecret {
+ for client := range ch.userModes {
+ if (present || 0 == client.mode&ircUserModeInvisible) &&
+ (!onlyOps || 0 != client.mode&ircUserModeOperator) {
+ ircSendRPLWHOREPLY(c, ch, client)
+ }
+ }
+ }
+ } else {
+ for _, client := range users {
+ if !onlyOps || 0 != client.mode&ircUserModeOperator {
+ ircMatchSendRPLWHOREPLY(c, client, usedMask)
+ }
+ }
+ }
+ c.sendReply(RPL_ENDOFWHO, shownMask)
+}
+
+func ircSendWHOISReply(c, target *client) {
+ nick := target.nickname
+ c.sendReply(RPL_WHOISUSER, nick,
+ target.username, target.hostname, target.realname)
+ c.sendReply(RPL_WHOISSERVER, nick,
+ serverName, "TODO server_info from configuration")
+ if 0 != target.mode&ircUserModeOperator {
+ c.sendReply(RPL_WHOISOPERATOR, nick)
+ }
+ c.sendReply(RPL_WHOISIDLE, nick,
+ (time.Now().UnixNano()-target.lastActive)/int64(time.Second))
+ if target.awayMessage != "" {
+ c.sendReply(RPL_AWAY, nick, target.awayMessage)
+ }
+
+ var chans []string
+ for _, ch := range channels {
+ _, presentClient := ch.userModes[c]
+ modes, presentTarget := ch.userModes[target]
+ if presentTarget && (presentClient ||
+ 0 == ch.modes&(ircChanModePrivate|ircChanModeSecret)) {
+ // TODO: Deduplicate, ircAppendPrefixes just also cuts prefixes.
+ var all []byte
+ if 0 != modes&ircChanModeOperator {
+ all = append(all, '@')
+ }
+ if 0 != modes&ircChanModeVoice {
+ all = append(all, '+')
+ }
+ chans = append(chans, string(all)+ch.name)
+ }
+ }
+ c.sendReplyVector(RPL_WHOISCHANNELS, chans, nick, "")
+ c.sendReply(RPL_ENDOFWHOIS, nick)
+}
+
+func ircHandleWHOIS(msg *message, c *client) {
+ if len(msg.params) < 1 {
+ c.sendReply(ERR_NEEDMOREPARAMS, msg.command)
+ return
+ }
+ if len(msg.params) > 1 && !isThisMe(msg.params[0]) {
+ c.sendReply(ERR_NOSUCHSERVER, msg.params[0])
+ return
+ }
+
+ masksStr := msg.params[0]
+ if len(msg.params) > 1 {
+ masksStr = msg.params[1]
+ }
+
+ for _, mask := range splitString(masksStr, ",", true /* ignoreEmpty */) {
+ if strings.IndexAny(mask, "*?") < 0 {
+ if target := users[ircToCanon(mask)]; target == nil {
+ c.sendReply(ERR_NOSUCHNICK, mask)
+ } else {
+ ircSendWHOISReply(c, target)
+ }
+ } else {
+ found := false
+ for _, target := range users {
+ if ircFnmatch(mask, target.nickname) {
+ ircSendWHOISReply(c, target)
+ found = true
+ }
+ }
+ if !found {
+ c.sendReply(ERR_NOSUCHNICK, mask)
+ }
+ }
+ }
+}
+
+func ircHandleWHOWAS(msg *message, c *client) {
+ if len(msg.params) < 1 {
+ c.sendReply(ERR_NEEDMOREPARAMS, msg.command)
+ return
+ }
+ if len(msg.params) > 2 && !isThisMe(msg.params[2]) {
+ c.sendReply(ERR_NOSUCHSERVER, msg.params[2])
+ return
+ }
+ // The "count" parameter is ignored, we only store one entry for a nick.
+
+ for _, nick := range splitString(msg.params[0], ",", true) {
+ if info := whowas[ircToCanon(nick)]; info == nil {
+ c.sendReply(ERR_WASNOSUCHNICK, nick)
+ } else {
+ c.sendReply(RPL_WHOWASUSER, nick,
+ info.username, info.hostname, info.realname)
+ c.sendReply(RPL_WHOISSERVER, nick,
+ serverName, "TODO server_info from configuration")
+ }
+ c.sendReply(RPL_ENDOFWHOWAS, nick)
+ }
+}
+
+func ircSendRPLTOPIC(c *client, ch *channel) {
+ if ch.topic == "" {
+ c.sendReply(RPL_NOTOPIC, ch.name)
+ } else {
+ c.sendReply(RPL_TOPIC, ch.name, ch.topic)
+ c.sendReply(RPL_TOPICWHOTIME,
+ ch.name, ch.topicWho, ch.topicTime/int64(time.Second))
+ }
+}
+
+func ircHandleTOPIC(msg *message, c *client) {
+ if len(msg.params) < 1 {
+ c.sendReply(ERR_NEEDMOREPARAMS, msg.command)
+ return
+ }
+
+ target := msg.params[0]
+ ch := channels[ircToCanon(target)]
+ if ch == nil {
+ c.sendReply(ERR_NOSUCHCHANNEL, target)
+ return
+ }
+
+ if len(msg.params) < 2 {
+ ircSendRPLTOPIC(c, ch)
+ return
+ }
+
+ modes, present := ch.userModes[c]
+ if !present {
+ c.sendReply(ERR_NOTONCHANNEL, target)
+ return
+ }
+
+ if 0 != ch.modes&ircChanModeProtectedTopic &&
+ 0 == modes&ircChanModeOperator {
+ c.sendReply(ERR_CHANOPRIVSNEEDED, target)
+ return
+ }
+
+ ch.topic = msg.params[1]
+ ch.topicWho = fmt.Sprintf("%s@%s@%s", c.nickname, c.username, c.hostname)
+ ch.topicTime = time.Now().UnixNano()
+
+ message := fmt.Sprintf(":%s!%s@%s TOPIC %s :%s",
+ c.nickname, c.username, c.hostname, target, ch.topic)
+ ircChannelMulticast(ch, message, nil)
+}
+
// TODO: All the various real command handlers.
func ircHandleX(msg *message, c *client) {
+ if len(msg.params) < 1 {
+ c.sendReply(ERR_NEEDMOREPARAMS, msg.command)
+ return
+ }
+}
+
+func ircHandleSUMMON(msg *message, c *client) {
+ c.sendReply(ERR_SUMMONDISABLED)
+}
+
+func ircHandleUSERS(msg *message, c *client) {
+ c.sendReply(ERR_USERSDISABLED)
+}
+
+// -----------------------------------------------------------------------------
+
+// TODO: Add an index for IRC_ERR_NOSUCHSERVER validation?
+// TODO: Add a minimal parameter count?
+// TODO: Add a field for oper-only commands?
+var ircHandlers = map[string]*ircCommand{
+ "CAP": {false, ircHandleCAP, 0, 0},
+ "PASS": {false, ircHandlePASS, 0, 0},
+ "NICK": {false, ircHandleNICK, 0, 0},
+ "USER": {false, ircHandleUSER, 0, 0},
+
+ "USERHOST": {true, ircHandleUSERHOST, 0, 0},
+ "LUSERS": {true, ircHandleLUSERS, 0, 0},
+ "MOTD": {true, ircHandleMOTD, 0, 0},
+ "PING": {true, ircHandlePING, 0, 0},
+ "PONG": {false, ircHandlePONG, 0, 0},
+ "QUIT": {false, ircHandleQUIT, 0, 0},
+ "TIME": {true, ircHandleTIME, 0, 0},
+ "VERSION": {true, ircHandleVERSION, 0, 0},
+ "USERS": {true, ircHandleUSERS, 0, 0},
+ "SUMMON": {true, ircHandleSUMMON, 0, 0},
+
+ "MODE": {true, ircHandleMODE, 0, 0},
+ "PRIVMSG": {true, ircHandlePRIVMSG, 0, 0},
+ "NOTICE": {true, ircHandleNOTICE, 0, 0},
+ "TOPIC": {true, ircHandleTOPIC, 0, 0},
+ "LIST": {true, ircHandleLIST, 0, 0},
+ "NAMES": {true, ircHandleNAMES, 0, 0},
+ "WHO": {true, ircHandleWHO, 0, 0},
+ "WHOIS": {true, ircHandleWHOIS, 0, 0},
+ "WHOWAS": {true, ircHandleWHOWAS, 0, 0},
+}
+
+func ircProcessMessage(c *client, msg *message, raw string) {
+ if c.closing {
+ return
+ }
+
+ c.nReceivedMessages++
+ c.receivedBytes += len(raw) + 2
+
+ if !c.antiflood.check() {
+ c.closeLink("Excess flood")
+ return
+ }
+
+ if cmd, ok := ircHandlers[ircToCanon(msg.command)]; !ok {
+ c.sendReply(ERR_UNKNOWNCOMMAND, msg.command)
+ } else {
+ cmd.nReceived++
+ cmd.bytesReceived += len(raw) + 2
+
+ if cmd.requiresRegistration && !c.registered {
+ c.sendReply(ERR_NOTREGISTERED)
+ } else {
+ cmd.handler(msg, c)
+ }
+ }
}
// --- ? -----------------------------------------------------------------------
@@ -1338,7 +1789,8 @@ func (c *client) onRead(data []byte, readErr error) {
msg.params = append(msg.params, x[1:])
}
- broadcast(line, c)
+ // XXX: And since it accepts LF, we miscalculate receivedBytes within.
+ ircProcessMessage(c, &msg, line)
}
if readErr != nil {
generated by cgit v1.2.3-70-g09d2 (git 2.47.1) at 2024-12-23 03:16:11 +0000