You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

client_lookup_set.go 7.8KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341
  1. // Copyright (c) 2012-2014 Jeremy Latt
  2. // Copyright (c) 2016-2017 Daniel Oaks <daniel@danieloaks.net>
  3. // released under the MIT license
  4. package irc
  5. import (
  6. "fmt"
  7. "log"
  8. "regexp"
  9. "strings"
  10. "github.com/goshuirc/irc-go/ircmatch"
  11. "github.com/oragono/oragono/irc/caps"
  12. "sync"
  13. )
  14. // ExpandUserHost takes a userhost, and returns an expanded version.
  15. func ExpandUserHost(userhost string) (expanded string) {
  16. expanded = userhost
  17. // fill in missing wildcards for nicks
  18. //TODO(dan): this would fail with dan@lol, fix that.
  19. if !strings.Contains(expanded, "!") {
  20. expanded += "!*"
  21. }
  22. if !strings.Contains(expanded, "@") {
  23. expanded += "@*"
  24. }
  25. return
  26. }
  27. // ClientManager keeps track of clients by nick, enforcing uniqueness of casefolded nicks
  28. type ClientManager struct {
  29. sync.RWMutex // tier 2
  30. byNick map[string]*Client
  31. }
  32. // NewClientManager returns a new ClientManager.
  33. func NewClientManager() *ClientManager {
  34. return &ClientManager{
  35. byNick: make(map[string]*Client),
  36. }
  37. }
  38. // Count returns how many clients are in the manager.
  39. func (clients *ClientManager) Count() int {
  40. clients.RLock()
  41. defer clients.RUnlock()
  42. count := len(clients.byNick)
  43. return count
  44. }
  45. // Get retrieves a client from the manager, if they exist.
  46. func (clients *ClientManager) Get(nick string) *Client {
  47. casefoldedName, err := CasefoldName(nick)
  48. if err == nil {
  49. clients.RLock()
  50. defer clients.RUnlock()
  51. cli := clients.byNick[casefoldedName]
  52. return cli
  53. }
  54. return nil
  55. }
  56. func (clients *ClientManager) removeInternal(client *Client) (removed bool) {
  57. // requires holding the writable Lock()
  58. oldcfnick := client.NickCasefolded()
  59. currentEntry, present := clients.byNick[oldcfnick]
  60. if present {
  61. if currentEntry == client {
  62. delete(clients.byNick, oldcfnick)
  63. removed = true
  64. } else {
  65. // this shouldn't happen, but we can ignore it
  66. client.server.logger.Warning("internal", fmt.Sprintf("clients for nick %s out of sync", oldcfnick))
  67. }
  68. }
  69. return
  70. }
  71. // Remove removes a client from the lookup set.
  72. func (clients *ClientManager) Remove(client *Client) error {
  73. clients.Lock()
  74. defer clients.Unlock()
  75. if !client.HasNick() {
  76. return errNickMissing
  77. }
  78. clients.removeInternal(client)
  79. return nil
  80. }
  81. // SetNick sets a client's nickname, validating it against nicknames in use
  82. func (clients *ClientManager) SetNick(client *Client, newNick string) error {
  83. newcfnick, err := CasefoldName(newNick)
  84. if err != nil {
  85. return err
  86. }
  87. var reservedAccount string
  88. var method NickReservationMethod
  89. if client.server.AccountConfig().NickReservation.Enabled {
  90. reservedAccount = client.server.accounts.NickToAccount(newcfnick)
  91. method = client.server.AccountConfig().NickReservation.Method
  92. }
  93. clients.Lock()
  94. defer clients.Unlock()
  95. clients.removeInternal(client)
  96. currentNewEntry := clients.byNick[newcfnick]
  97. // the client may just be changing case
  98. if currentNewEntry != nil && currentNewEntry != client {
  99. return errNicknameInUse
  100. }
  101. if method == NickReservationStrict && reservedAccount != client.Account() {
  102. return errNicknameReserved
  103. }
  104. clients.byNick[newcfnick] = client
  105. client.updateNickMask(newNick)
  106. return nil
  107. }
  108. func (clients *ClientManager) AllClients() (result []*Client) {
  109. clients.RLock()
  110. defer clients.RUnlock()
  111. result = make([]*Client, len(clients.byNick))
  112. i := 0
  113. for _, client := range clients.byNick {
  114. result[i] = client
  115. i++
  116. }
  117. return
  118. }
  119. // AllWithCaps returns all clients with the given capabilities.
  120. func (clients *ClientManager) AllWithCaps(capabs ...caps.Capability) (set ClientSet) {
  121. set = make(ClientSet)
  122. clients.RLock()
  123. defer clients.RUnlock()
  124. var client *Client
  125. for _, client = range clients.byNick {
  126. // make sure they have all the required caps
  127. for _, capab := range capabs {
  128. if !client.capabilities.Has(capab) {
  129. continue
  130. }
  131. }
  132. set.Add(client)
  133. }
  134. return set
  135. }
  136. // FindAll returns all clients that match the given userhost mask.
  137. func (clients *ClientManager) FindAll(userhost string) (set ClientSet) {
  138. set = make(ClientSet)
  139. userhost, err := Casefold(ExpandUserHost(userhost))
  140. if err != nil {
  141. return set
  142. }
  143. matcher := ircmatch.MakeMatch(userhost)
  144. clients.RLock()
  145. defer clients.RUnlock()
  146. for _, client := range clients.byNick {
  147. if matcher.Match(client.nickMaskCasefolded) {
  148. set.Add(client)
  149. }
  150. }
  151. return set
  152. }
  153. // Find returns the first client that matches the given userhost mask.
  154. func (clients *ClientManager) Find(userhost string) *Client {
  155. userhost, err := Casefold(ExpandUserHost(userhost))
  156. if err != nil {
  157. return nil
  158. }
  159. matcher := ircmatch.MakeMatch(userhost)
  160. var matchedClient *Client
  161. clients.RLock()
  162. defer clients.RUnlock()
  163. for _, client := range clients.byNick {
  164. if matcher.Match(client.nickMaskCasefolded) {
  165. matchedClient = client
  166. break
  167. }
  168. }
  169. return matchedClient
  170. }
  171. //
  172. // usermask to regexp
  173. //
  174. //TODO(dan): move this over to generally using glob syntax instead?
  175. // kinda more expected in normal ban/etc masks, though regex is useful (probably as an extban?)
  176. // UserMaskSet holds a set of client masks and lets you match hostnames to them.
  177. type UserMaskSet struct {
  178. sync.RWMutex
  179. masks map[string]bool
  180. regexp *regexp.Regexp
  181. }
  182. // NewUserMaskSet returns a new UserMaskSet.
  183. func NewUserMaskSet() *UserMaskSet {
  184. return &UserMaskSet{
  185. masks: make(map[string]bool),
  186. }
  187. }
  188. // Add adds the given mask to this set.
  189. func (set *UserMaskSet) Add(mask string) (added bool) {
  190. casefoldedMask, err := Casefold(mask)
  191. if err != nil {
  192. log.Println(fmt.Sprintf("ERROR: Could not add mask to usermaskset: [%s]", mask))
  193. return false
  194. }
  195. set.Lock()
  196. added = !set.masks[casefoldedMask]
  197. if added {
  198. set.masks[casefoldedMask] = true
  199. }
  200. set.Unlock()
  201. if added {
  202. set.setRegexp()
  203. }
  204. return
  205. }
  206. // AddAll adds the given masks to this set.
  207. func (set *UserMaskSet) AddAll(masks []string) (added bool) {
  208. set.Lock()
  209. defer set.Unlock()
  210. for _, mask := range masks {
  211. if !added && !set.masks[mask] {
  212. added = true
  213. }
  214. set.masks[mask] = true
  215. }
  216. if added {
  217. set.setRegexp()
  218. }
  219. return
  220. }
  221. // Remove removes the given mask from this set.
  222. func (set *UserMaskSet) Remove(mask string) (removed bool) {
  223. set.Lock()
  224. removed = set.masks[mask]
  225. if removed {
  226. delete(set.masks, mask)
  227. }
  228. set.Unlock()
  229. if removed {
  230. set.setRegexp()
  231. }
  232. return
  233. }
  234. // Match matches the given n!u@h.
  235. func (set *UserMaskSet) Match(userhost string) bool {
  236. set.RLock()
  237. regexp := set.regexp
  238. set.RUnlock()
  239. if regexp == nil {
  240. return false
  241. }
  242. return regexp.MatchString(userhost)
  243. }
  244. // String returns the masks in this set.
  245. func (set *UserMaskSet) String() string {
  246. set.RLock()
  247. masks := make([]string, len(set.masks))
  248. index := 0
  249. for mask := range set.masks {
  250. masks[index] = mask
  251. index++
  252. }
  253. set.RUnlock()
  254. return strings.Join(masks, " ")
  255. }
  256. func (set *UserMaskSet) Length() int {
  257. set.RLock()
  258. defer set.RUnlock()
  259. return len(set.masks)
  260. }
  261. // setRegexp generates a regular expression from the set of user mask
  262. // strings. Masks are split at the two types of wildcards, `*` and
  263. // `?`. All the pieces are meta-escaped. `*` is replaced with `.*`,
  264. // the regexp equivalent. Likewise, `?` is replaced with `.`. The
  265. // parts are re-joined and finally all masks are joined into a big
  266. // or-expression.
  267. func (set *UserMaskSet) setRegexp() {
  268. var re *regexp.Regexp
  269. set.RLock()
  270. maskExprs := make([]string, len(set.masks))
  271. index := 0
  272. for mask := range set.masks {
  273. manyParts := strings.Split(mask, "*")
  274. manyExprs := make([]string, len(manyParts))
  275. for mindex, manyPart := range manyParts {
  276. oneParts := strings.Split(manyPart, "?")
  277. oneExprs := make([]string, len(oneParts))
  278. for oindex, onePart := range oneParts {
  279. oneExprs[oindex] = regexp.QuoteMeta(onePart)
  280. }
  281. manyExprs[mindex] = strings.Join(oneExprs, ".")
  282. }
  283. maskExprs[index] = strings.Join(manyExprs, ".*")
  284. index++
  285. }
  286. set.RUnlock()
  287. if index > 0 {
  288. expr := "^" + strings.Join(maskExprs, "|") + "$"
  289. re, _ = regexp.Compile(expr)
  290. }
  291. set.Lock()
  292. set.regexp = re
  293. set.Unlock()
  294. }