1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
|
/*
* InspIRCd -- Internet Relay Chat Daemon
*
* Copyright (C) 2012 Attila Molnar <attilamolnar@hush.com>
*
* This file is part of InspIRCd. InspIRCd is free software: you can
* redistribute it and/or modify it under the terms of the GNU General Public
* License as published by the Free Software Foundation, version 2.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
* details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "inspircd.h"
#include "modules/account.h"
#include "modules/cap.h"
class ModuleIRCv3 : public Module
{
GenericCap cap_accountnotify;
GenericCap cap_awaynotify;
GenericCap cap_extendedjoin;
bool accountnotify;
bool awaynotify;
bool extendedjoin;
CUList last_excepts;
void WriteNeighboursWithExt(User* user, const std::string& line, const LocalIntExt& ext)
{
UserChanList chans(user->chans);
std::map<User*, bool> exceptions;
FOREACH_MOD(OnBuildNeighborList, (user, chans, exceptions));
// Send it to all local users who were explicitly marked as neighbours by modules and have the required ext
for (std::map<User*, bool>::const_iterator i = exceptions.begin(); i != exceptions.end(); ++i)
{
LocalUser* u = IS_LOCAL(i->first);
if ((u) && (i->second) && (ext.get(u)))
u->Write(line);
}
// Now consider sending it to all other users who has at least a common channel with the user
std::set<User*> already_sent;
for (UCListIter i = chans.begin(); i != chans.end(); ++i)
{
const UserMembList* userlist = (*i)->GetUsers();
for (UserMembList::const_iterator m = userlist->begin(); m != userlist->end(); ++m)
{
/*
* Send the line if the channel member in question meets all of the following criteria:
* - local
* - not the user who is doing the action (i.e. whose channels we're iterating)
* - has the given extension
* - not on the except list built by modules
* - we haven't sent the line to the member yet
*
*/
LocalUser* member = IS_LOCAL(m->first);
if ((member) && (member != user) && (ext.get(member)) && (exceptions.find(member) == exceptions.end()) && (already_sent.insert(member).second))
member->Write(line);
}
}
}
public:
ModuleIRCv3() : cap_accountnotify(this, "account-notify"),
cap_awaynotify(this, "away-notify"),
cap_extendedjoin(this, "extended-join")
{
}
void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
{
ConfigTag* conf = ServerInstance->Config->ConfValue("ircv3");
accountnotify = conf->getBool("accountnotify", true);
awaynotify = conf->getBool("awaynotify", true);
extendedjoin = conf->getBool("extendedjoin", true);
}
void OnEvent(Event& ev) CXX11_OVERRIDE
{
if (awaynotify)
cap_awaynotify.HandleEvent(ev);
if (extendedjoin)
cap_extendedjoin.HandleEvent(ev);
if (accountnotify)
{
cap_accountnotify.HandleEvent(ev);
if (ev.id == "account_login")
{
AccountEvent* ae = static_cast<AccountEvent*>(&ev);
// :nick!user@host ACCOUNT account
// or
// :nick!user@host ACCOUNT *
std::string line = ":" + ae->user->GetFullHost() + " ACCOUNT ";
if (ae->account.empty())
line += "*";
else
line += std::string(ae->account);
WriteNeighboursWithExt(ae->user, line, cap_accountnotify.ext);
}
}
}
void OnUserJoin(Membership* memb, bool sync, bool created, CUList& excepts) CXX11_OVERRIDE
{
// Remember who is not going to see the JOIN because of other modules
if ((awaynotify) && (memb->user->IsAway()))
last_excepts = excepts;
if (!extendedjoin)
return;
/*
* Send extended joins to clients who have the extended-join capability.
* An extended join looks like this:
*
* :nick!user@host JOIN #chan account :realname
*
* account is the joining user's account if he's logged in, otherwise it's an asterisk (*).
*/
std::string line;
std::string mode;
const UserMembList* userlist = memb->chan->GetUsers();
for (UserMembCIter it = userlist->begin(); it != userlist->end(); ++it)
{
// Send the extended join line if the current member is local, has the extended-join cap and isn't excepted
User* member = IS_LOCAL(it->first);
if ((member) && (cap_extendedjoin.ext.get(member)) && (excepts.find(member) == excepts.end()))
{
// Construct the lines we're going to send if we haven't constructed them already
if (line.empty())
{
bool has_account = false;
line = ":" + memb->user->GetFullHost() + " JOIN " + memb->chan->name + " ";
const AccountExtItem* accountext = GetAccountExtItem();
if (accountext)
{
std::string* accountname;
accountname = accountext->get(memb->user);
if (accountname)
{
line += *accountname;
has_account = true;
}
}
if (!has_account)
line += "*";
line += " :" + memb->user->fullname;
// If the joining user received privileges from another module then we must send them as well,
// since silencing the normal join means the MODE will be silenced as well
if (!memb->modes.empty())
{
const std::string& modefrom = ServerInstance->Config->CycleHostsFromUser ? memb->user->GetFullHost() : ServerInstance->Config->ServerName;
mode = ":" + modefrom + " MODE " + memb->chan->name + " +" + memb->modes;
for (unsigned int i = 0; i < memb->modes.length(); i++)
mode += " " + memb->user->nick;
}
}
// Write the JOIN and the MODE, if any
member->Write(line);
if ((!mode.empty()) && (member != memb->user))
member->Write(mode);
// Prevent the core from sending the JOIN and MODE to this user
excepts.insert(it->first);
}
}
}
ModResult OnSetAway(User* user, const std::string &awaymsg) CXX11_OVERRIDE
{
if (awaynotify)
{
// Going away: n!u@h AWAY :reason
// Back from away: n!u@h AWAY
std::string line = ":" + user->GetFullHost() + " AWAY";
if (!awaymsg.empty())
line += " :" + awaymsg;
WriteNeighboursWithExt(user, line, cap_awaynotify.ext);
}
return MOD_RES_PASSTHRU;
}
void OnPostJoin(Membership *memb) CXX11_OVERRIDE
{
if ((!awaynotify) || (!memb->user->IsAway()))
return;
std::string line = ":" + memb->user->GetFullHost() + " AWAY :" + memb->user->awaymsg;
const UserMembList* userlist = memb->chan->GetUsers();
for (UserMembCIter it = userlist->begin(); it != userlist->end(); ++it)
{
// Send the away notify line if the current member is local, has the away-notify cap and isn't excepted
User* member = IS_LOCAL(it->first);
if ((member) && (cap_awaynotify.ext.get(member)) && (last_excepts.find(member) == last_excepts.end()))
{
member->Write(line);
}
}
last_excepts.clear();
}
void Prioritize()
{
ServerInstance->Modules->SetPriority(this, I_OnUserJoin, PRIORITY_LAST);
}
Version GetVersion() CXX11_OVERRIDE
{
return Version("Provides support for extended-join, away-notify and account-notify CAP capabilities", VF_VENDOR);
}
};
MODULE_INIT(ModuleIRCv3)
|
