1 /* chanserv.c - Channel service bot
2 * Copyright 2000-2004 srvx Development Team
4 * This file is part of x3.
6 * srvx is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with srvx; if not, write to the Free Software Foundation,
18 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
25 #include "opserv.h" /* for opserv_bad_channel() */
29 #define CHANSERV_CONF_NAME "services/chanserv"
31 /* ChanServ options */
32 #define KEY_SUPPORT_CHANNEL "support_channel"
33 #define KEY_SUPPORT_CHANNEL_MODES "support_channel_modes"
34 #define KEY_DB_BACKUP_FREQ "db_backup_freq"
35 #define KEY_INFO_DELAY "info_delay"
36 #define KEY_MAX_GREETLEN "max_greetlen"
37 #define KEY_ADJUST_THRESHOLD "adjust_threshold"
38 #define KEY_ADJUST_DELAY "adjust_delay"
39 #define KEY_CHAN_EXPIRE_FREQ "chan_expire_freq"
40 #define KEY_CHAN_EXPIRE_DELAY "chan_expire_delay"
41 #define KEY_BAN_TIMEOUT_FREQ "ban_timeout_freq"
42 #define KEY_MAX_CHAN_USERS "max_chan_users"
43 #define KEY_MAX_CHAN_BANS "max_chan_bans"
44 #define KEY_NICK "nick"
45 #define KEY_OLD_CHANSERV_NAME "old_chanserv_name"
46 #define KEY_8BALL_RESPONSES "8ball"
47 #define KEY_OLD_BAN_NAMES "old_ban_names"
48 #define KEY_REFRESH_PERIOD "refresh_period"
49 #define KEY_CTCP_SHORT_BAN_DURATION "ctcp_short_ban_duration"
50 #define KEY_CTCP_LONG_BAN_DURATION "ctcp_long_ban_duration"
51 #define KEY_MAX_OWNED "max_owned"
52 #define KEY_IRC_OPERATOR_EPITHET "irc_operator_epithet"
53 #define KEY_NETWORK_HELPER_EPITHET "network_helper_epithet"
54 #define KEY_SUPPORT_HELPER_EPITHET "support_helper_epithet"
55 #define KEY_NODELETE_LEVEL "nodelete_level"
56 #define KEY_MAX_USERINFO_LENGTH "max_userinfo_length"
57 #define KEY_GIVEOWNERSHIP_PERIOD "giveownership_timeout"
59 /* ChanServ database */
60 #define KEY_VERSION_CONTROL "version_control"
61 #define KEY_CHANNELS "channels"
62 #define KEY_NOTE_TYPES "note_types"
64 /* version control paramiter */
65 #define KEY_VERSION_NUMBER "version_number"
67 /* Note type parameters */
68 #define KEY_NOTE_OPSERV_ACCESS "opserv_access"
69 #define KEY_NOTE_CHANNEL_ACCESS "channel_access"
70 #define KEY_NOTE_SETTER_ACCESS "setter_access"
71 #define KEY_NOTE_VISIBILITY "visibility"
72 #define KEY_NOTE_VIS_PRIVILEGED "privileged"
73 #define KEY_NOTE_VIS_CHANNEL_USERS "channel_users"
74 #define KEY_NOTE_VIS_ALL "all"
75 #define KEY_NOTE_MAX_LENGTH "max_length"
76 #define KEY_NOTE_SETTER "setter"
77 #define KEY_NOTE_NOTE "note"
79 /* Do-not-register channels */
81 #define KEY_DNR_SET "set"
82 #define KEY_DNR_SETTER "setter"
83 #define KEY_DNR_REASON "reason"
86 #define KEY_REGISTERED "registered"
87 #define KEY_REGISTRAR "registrar"
88 #define KEY_SUSPENDED "suspended"
89 #define KEY_PREVIOUS "previous"
90 #define KEY_SUSPENDER "suspender"
91 #define KEY_ISSUED "issued"
92 #define KEY_REVOKED "revoked"
93 #define KEY_SUSPEND_EXPIRES "suspend_expires"
94 #define KEY_SUSPEND_REASON "suspend_reason"
95 #define KEY_VISITED "visited"
96 #define KEY_TOPIC "topic"
97 #define KEY_GREETING "greeting"
98 #define KEY_USER_GREETING "user_greeting"
99 #define KEY_MODES "modes"
100 #define KEY_FLAGS "flags"
101 #define KEY_OPTIONS "options"
102 #define KEY_USERS "users"
103 #define KEY_BANS "bans" /* for lamers */
104 #define KEY_MAX "max"
105 #define KEY_NOTES "notes"
106 #define KEY_TOPIC_MASK "topic_mask"
107 #define KEY_OWNER_TRANSFER "owner_transfer"
110 #define KEY_LEVEL "level"
111 #define KEY_INFO "info"
112 #define KEY_SEEN "seen"
115 #define KEY_OWNER "owner"
116 #define KEY_REASON "reason"
117 #define KEY_SET "set"
118 #define KEY_DURATION "duration"
119 #define KEY_EXPIRES "expires"
120 #define KEY_TRIGGERED "triggered"
122 #define CHANNEL_DEFAULT_FLAGS (CHANNEL_OFFCHANNEL)
123 #define CHANNEL_DEFAULT_OPTIONS "lmoooanpcnat"
125 /* Administrative messages */
126 static const struct message_entry msgtab
[] = {
127 { "CSMSG_CHANNELS_EXPIRED", "%i channels expired." },
129 /* Channel registration */
130 { "CSMSG_REG_SUCCESS", "You now have ownership of $b%s$b." },
131 { "CSMSG_PROXY_SUCCESS", "%s now has ownership of $b%s$b." },
132 { "CSMSG_ALREADY_REGGED", "$b%s$b is registered to someone else." },
133 { "CSMSG_MUST_BE_OPPED", "You must be a channel operator (+o) in $b%s$b to register it." },
134 { "CSMSG_PROXY_FORBIDDEN", "You may not register a channel for someone else." },
135 { "CSMSG_OWN_TOO_MANY", "%s already owns more than the limit of %d channels. Use FORCE to override." },
136 { "CSMSG_YOU_OWN_TOO_MANY", "You already own more than the limit of %d channels. Ask a staff member for help." },
137 { "CSMSG_ANOTHER_SERVICE", "Another service bot is in that channel already. Ask a staff member for help." },
139 /* Do-not-register channels */
140 { "CSMSG_NOT_DNR", "$b%s$b is not a valid channel name or *account." },
141 { "CSMSG_DNR_SEARCH_RESULTS", "$bDo-Not-Register Channels$b" },
142 { "CSMSG_DNR_INFO", "$b%s$b (set by $b%s$b): %s" },
143 { "CSMSG_DNR_INFO_SET", "$b%s$b (set %s ago by $b%s$b): %s" },
144 { "CSMSG_MORE_DNRS", "%d more do-not-register entries skipped." },
145 { "CSMSG_DNR_CHANNEL", "Only network staff may register $b%s$b." },
146 { "CSMSG_DNR_CHANNEL_MOVE", "Only network staff may move $b%s$b." },
147 { "CSMSG_DNR_ACCOUNT", "Only network staff may register channels to $b%s$b." },
148 { "CSMSG_NOREGISTER_CHANNEL", "$b%s$b has been added to the do-not-register list." },
149 { "CSMSG_NO_SUCH_DNR", "$b%s$b is not in the do-not-register list." },
150 { "CSMSG_DNR_REMOVED", "$b%s$b has been removed from the do-not-register list." },
152 /* Channel unregistration */
153 { "CSMSG_UNREG_SUCCESS", "$b%s$b has been unregistered." },
154 { "CSMSG_UNREG_NODELETE", "$b%s$b is protected from unregistration." },
155 { "CSMSG_CHAN_SUSPENDED", "$b$C$b access to $b%s$b has been temporarily suspended (%s)." },
156 { "CSMSG_CONFIRM_UNREG", "To confirm this unregistration, you must use 'unregister %s %s'." },
159 { "CSMSG_MOVE_SUCCESS", "Channel registration has been moved to $b%s$b." },
160 { "CSMSG_MOVE_NODELETE", "$b%s$b is protected from unregistration, and cannot be moved." },
162 /* Channel merging */
163 { "CSMSG_MERGE_SUCCESS", "Channel successfully merged into $b%s$b." },
164 { "CSMSG_MERGE_SELF", "Merging cannot be performed if the source and target channels are the same." },
165 { "CSMSG_MERGE_NODELETE", "You may not merge a channel that is marked NoDelete." },
166 { "CSMSG_MERGE_SUSPENDED", "Merging cannot be performed if the source or target channel is suspended." },
167 { "CSMSG_MERGE_NOT_OWNER", "You must be the owner of the target channel (or a helper) to merge into the channel." },
169 /* Handle unregistration */
170 { "CSMSG_HANDLE_UNREGISTERED", "As a result of your account unregistration, you have been deleted from all of your channels' userlists." },
173 { "CSMSG_NOT_USER", "You lack access to $b%s$b." },
174 { "CSMSG_NO_CHAN_USER", "%s lacks access to $b%s$b." },
175 { "CSMSG_NO_ACCESS", "You lack sufficient access to use this command." },
176 { "CSMSG_NOT_REGISTERED", "$b%s$b has not been registered with $b$C$b." },
177 { "CSMSG_MAXIMUM_LAMERS", "This channel has reached the lamer count limit of $b%d$b." },
178 { "CSMSG_MAXIMUM_USERS", "This channel has reached the user count limit of $b%d$b." },
179 { "CSMSG_ILLEGAL_CHANNEL", "$b%s$b is an illegal channel, and cannot be registered." },
180 { "CSMSG_GODMODE_UP", "You may not use $b%s$b to op yourself unless you are on the user list. Use the $bop$b command instead." },
181 { "CSMSG_ALREADY_OPPED", "You are already opped in $b%s$b." },
182 { "CSMSG_ALREADY_HALFOPPED", "You are already halfopped in $b%s$b." },
183 { "CSMSG_ALREADY_VOICED", "You are already voiced in $b%s$b." },
184 { "CSMSG_ALREADY_DOWN", "You are not opped, halfopped, or voiced in $b%s$b." },
185 { "CSMSG_ALREADY_OPCHANNED", "There has been no net.join since the last opchan in $b%s$b." },
186 { "CSMSG_OPCHAN_DONE", "I have (re-)opped myself in $b%s$b." },
188 /* Removing yourself from a channel. */
189 { "CSMSG_NO_OWNER_DELETEME", "You cannot delete your owner access in $b%s$b." },
190 { "CSMSG_CONFIRM_DELETEME", "To really remove yourself, you must use 'deleteme %s'." },
191 { "CSMSG_DELETED_YOU", "Your $b%d$b access has been deleted from $b%s$b." },
193 /* User management */
194 { "CSMSG_ADDED_USER", "Added %s to the %s user list with access %s (%d)." },
195 { "CSMSG_DELETED_USER", "Deleted %s (with access %d) from the %s user list." },
196 { "CSMSG_BAD_RANGE", "Invalid access range; minimum (%d) must be greater than maximum (%d)." },
197 { "CSMSG_DELETED_USERS", "Deleted accounts matching $b%s$b with access from $b%d$b to $b%d$b from the %s user list." },
198 { "CSMSG_TRIMMED_USERS", "Trimmed $b%d users$b with access from %d to %d from the %s user list who were inactive for at least %s." },
199 { "CSMSG_INCORRECT_ACCESS", "%s has access $b%s$b, not %s." },
200 { "CSMSG_USER_EXISTS", "%s is already on the $b%s$b user list (with %s access)." },
201 { "CSMSG_ADDUSER_PENDING", "I have sent him/her a message letting them know, and if they auth or register soon, I will finish adding them automatically." },
202 { "CSMSG_ADDUSER_PENDING_ALREADY", "He or she is already pending addition to %s once he/she auths with $b$N$b." },
203 { "CSMSG_ADDUSER_PENDING_HEADER", "Users to add to channels pending logins:" }, /* Remove after testing? */
204 { "CSMSG_ADDUSER_PENDING_LIST", "Channel %s user %s" }, /* Remove after testing? */
205 { "CSMSG_ADDUSER_PENDING_FOOTER", "--------- End of pending list ----------" }, /* Remove after testing? */
206 /*{ "CSMSG_ADDUSER_PENDING_NOTINCHAN", "That user is not in %s, and is not auth'd." }, */
207 { "CSMSG_ADDUSER_PENDING_TARGET", "Channel Services bot here: %s would like to add you to my userlist in channel %s, but you are not authenticated to $b$N$b. Please authenticate now and you will be added. If you do not have an account, type /msg $N help register" },
208 { "CSMSG_CANNOT_TRIM", "You must include a minimum inactivity duration of at least 60 seconds to trim." },
210 { "CSMSG_NO_SELF_CLVL", "You cannot change your own access." },
211 { "CSMSG_NO_BUMP_ACCESS", "You cannot give users access greater than or equal to your own." },
212 { "CSMSG_MULTIPLE_OWNERS", "There is more than one owner in %s; please use $bCLVL$b, $bDELOWNER$b and/or $bADDOWNER$b instead." },
213 { "CSMSG_TRANSFER_WAIT", "You must wait %s before you can give ownership of $b%s$b to someone else." },
214 { "CSMSG_NO_TRANSFER_SELF", "You cannot give ownership to your own account." },
215 { "CSMSG_OWNERSHIP_GIVEN", "Ownership of $b%s$b has been transferred to account $b%s$b." },
218 { "CSMSG_LAMER_ADDED", "Added $b%s$b to %s LAMERs." },
219 { "CSMSG_TIMED_LAMER_ADDED", "LAMERed $b%s$b on %s for %s." },
220 { "CSMSG_KICK_BAN_DONE", "Kickbanned $b%s$b from %s." },
221 { "CSMSG_BAN_DONE", "Banned $b%s$b from %s." },
222 { "CSMSG_REASON_CHANGE", "Reason for LAMER $b%s$b changed." },
223 { "CSMSG_LAMER_EXTENDED", "Extended LAMER for $b%s$b, now expires in %s." },
224 { "CSMSG_BAN_REMOVED", "Matching ban(s) and LAMER(s) in $b%s$b were removed." },
225 { "CSMSG_TRIMMED_LAMERS", "Trimmed $b%d LAMERs$b from the %s LAMER list that were inactive for at least %s." },
226 { "CSMSG_REDUNDANT_BAN", "$b%s$b is already banned in %s." },
227 { "CSMSG_REDUNDANT_LAMER", "$b%s$b is already LAMER'd in %s." },
228 { "CSMSG_DURATION_TOO_LOW", "Timed bans must last for at least 15 seconds." },
229 { "CSMSG_DURATION_TOO_HIGH", "Timed bans must last for less than 2 years." },
230 { "CSMSG_LAME_MASK", "$b%s$b is a little too general. Try making it more specific." },
231 { "CSMSG_MASK_PROTECTED", "Sorry, ban for $b%s$b conflicts with a protected user's hostmask." },
232 { "CSMSG_NO_MATCHING_USERS", "No one in $b%s$b has a hostmask matching $b%s$b." },
233 { "CSMSG_BAN_NOT_FOUND", "Sorry, no ban or LAMER found: $b%s$b." },
234 { "CSMSG_BANLIST_FULL", "The $b%s$b channel ban list is $bfull$b." },
236 { "CSMSG_INVALID_TRIM", "$b%s$b isn't a valid trim target." },
238 /* Channel management */
239 { "CSMSG_CHANNEL_OPENED", "$b%s$b has been opened." },
240 { "CSMSG_WIPED_INFO_LINE", "Removed $b%s$b's infoline in $b%s$b." },
241 { "CSMSG_RESYNCED_USERS", "Synchronized users in $b%s$b with the userlist." },
243 { "CSMSG_TOPIC_SET", "Topic is now '%s'." },
244 { "CSMSG_NO_TOPIC", "$b%s$b does not have a default topic." },
245 { "CSMSG_TOPICMASK_CONFLICT1", "I do not know how to make that topic work with the current topic mask in $b%s$b, which is: %s" },
246 { "CSMSG_TOPICMASK_CONFLICT2", "Please make sure your topic is at most %d characters and matches the topic mask pattern." },
247 { "CSMSG_TOPIC_LOCKED", "The %s topic is locked." },
248 { "CSMSG_MASK_BUT_NO_TOPIC", "Warning: $b%s$b does not have a default topic, but you just set the topic mask." },
249 { "CSMSG_TOPIC_MISMATCH", "Warning: The default topic for $b%s$b does not match the topic mask; changing it anyway." },
251 { "CSMSG_MODES_SET", "Channel modes are now $b%s$b." },
252 { "CSMSG_DEFAULTED_MODES", "Channel modes for $b%s$b are set to their defaults." },
253 { "CSMSG_NO_MODES", "$b%s$b does not have any default modes." },
254 { "CSMSG_MODE_LOCKED", "Modes conflicting with $b%s$b are not allowed in %s." },
255 { "CSMSG_CANNOT_SET", "That setting is above your current level, so you cannot change it." },
256 { "CSMSG_OWNER_DEFAULTS", "You must have access 500 in %s to reset it to the default options." },
257 { "CSMSG_CONFIRM_DEFAULTS", "To reset %s's settings to the defaults, you must use 'set defaults %s'." },
258 { "CSMSG_SETTINGS_DEFAULTED", "All settings for %s have been reset to default values." },
259 { "CSMSG_BAD_SETLEVEL", "You cannot change any setting to above your level." },
260 { "CSMSG_BAD_SETTERS", "You cannot change Setters to above your level." },
261 { "CSMSG_INVALID_MODE_LOCK", "$b%s$b is an invalid mode lock." },
262 { "CSMSG_INVALID_NUMERIC", "$b%d$b is not a valid choice. Choose one:" },
263 { "CSMSG_SET_DEFAULT_TOPIC", "$bDefaultTopic$b %s" },
264 { "CSMSG_SET_TOPICMASK", "$bTopicMask $b %s" },
265 { "CSMSG_SET_GREETING", "$bGreeting $b %s" },
266 { "CSMSG_SET_USERGREETING", "$bUserGreeting$b %s" },
267 { "CSMSG_SET_MODES", "$bModes $b %s" },
268 { "CSMSG_SET_NODELETE", "$bNoDelete $b %s" },
269 { "CSMSG_SET_DYNLIMIT", "$bDynLimit $b %s - +l joinflood protection." },
270 { "CSMSG_SET_OFFCHANNEL", "$bOffChannel $b %s" },
271 { "CSMSG_SET_USERINFO", "$bUserInfo $b %d - and above userinfos are shown." },
272 { "CSMSG_SET_TOPICSNARF", "$bTopicSnarf $b %d" },
273 { "CSMSG_SET_INVITEME", "$bInviteMe $b %d - Userlevel required to invite self." },
274 { "CSMSG_SET_ENFOPS", "$bEnfOps $b %d - level and above can op unknown users." },
275 { "CSMSG_SET_ENFHALFOPS", "$bEnfHalfOps $b %d - level and above can hop unknown users." },
276 { "CSMSG_SET_ENFMODES", "$bEnfModes $b %d - and above can change channel modes." },
277 { "CSMSG_SET_ENFTOPIC", "$bEnfTopic $b %d - and above can set the topic." },
278 { "CSMSG_SET_PUBCMD", "$bPubCmd $b %d - and above can use public commands." },
279 { "CSMSG_SET_SETTERS", "$bSetters $b %d - and above can change these settings." },
280 { "CSMSG_SET_AUTOMODE", "$bAutoMode $b %d - %s" },
281 { "CSMSG_SET_PROTECT", "$bProtect $b %d - %s" },
282 { "CSMSG_SET_TOYS", "$bToys $b %d - %s" },
283 { "CSMSG_SET_CTCPREACTION", "$bCTCPReaction$b %d - %s" },
284 { "CSMSG_SET_TOPICREFRESH", "$bTopicRefresh$b %d - %s" },
285 { "CSMSG_SET_BANTIMEOUT", "$bBanTimeout $b %d - %s" },
287 { "CSMSG_USET_AUTOOP", "$bAutoOp $b %s" },
288 { "CSMSG_USET_AUTOVOICE", "$bAutoVoice $b %s" },
289 { "CSMSG_USET_AUTOINVITE", "$bAutoInvite $b %s" },
290 { "CSMSG_USET_INFO", "$bInfo $b %s" },
292 { "CSMSG_USER_PROTECTED", "Sorry, $b%s$b is protected." },
293 { "CSMSG_USER_PROTECTED_KICK", "That user is protected." }, /* No $ or %s replacements! */
294 { "CSMSG_OPBY_LOCKED", "You may not op users who lack op or greater access." },
295 { "CSMSG_HOPBY_LOCKED", "You may not halfop users who lack halfop or greater access." },
296 { "CSMSG_PROCESS_FAILED", "$b$C$b could not process some of the nicks you provided." },
297 { "CSMSG_OPPED_USERS", "Opped users in $b%s$b." },
298 { "CSMSG_HALFOPPED_USERS", "Halfopped users in $b%s$b." },
299 { "CSMSG_DEOPPED_USERS", "Deopped users in $b%s$b." },
300 { "CSMSG_DEHALFOPPED_USERS", "DeHalfopped users in $b%s$b." },
301 { "CSMSG_VOICED_USERS", "Voiced users in $b%s$b." },
302 { "CSMSG_DEVOICED_USERS", "Devoiced users in $b%s$b." },
304 { "CSMSG_AUTOMODE_NONE", "Noone will be automatically oped, half-oped, or voiced." },
305 { "CSMSG_AUTOMODE_NORMAL", "Give voice to peons, half-op to halfops, and op to ops." },
306 { "CSMSG_AUTOMODE_VOICE", "#1 plus give voice to everyone." },
307 { "CSMSG_AUTOMODE_HOP", "#1 plus give halfops to everyone." },
308 { "CSMSG_AUTOMODE_OP", "#1 plus give ops to everyone (not advised)" },
309 { "CSMSG_AUTOMODE_MUTE", "Give half-op to halfops, and op to ops only." },
311 { "CSMSG_PROTECT_ALL", "Non-users and users will be protected from those of equal or lower access." },
312 { "CSMSG_PROTECT_EQUAL", "Users will be protected from those of equal or lower access." },
313 { "CSMSG_PROTECT_LOWER", "Users will be protected from those of lower access." },
314 { "CSMSG_PROTECT_NONE", "No users will be protected." },
315 { "CSMSG_TOYS_DISABLED", "Toys are completely disabled." },
316 { "CSMSG_TOYS_PRIVATE", "Toys will only reply privately." },
317 { "CSMSG_TOYS_PUBLIC", "Toys will reply publicly." },
319 { "CSMSG_TOPICREFRESH_NEVER", "Never refresh topic." },
320 { "CSMSG_TOPICREFRESH_3_HOURS", "Refresh every 3 hours." },
321 { "CSMSG_TOPICREFRESH_6_HOURS", "Refresh every 6 hours." },
322 { "CSMSG_TOPICREFRESH_12_HOURS", "Refresh every 12 hours." },
323 { "CSMSG_TOPICREFRESH_24_HOURS", "Refresh every 24 hours." },
325 { "CSMSG_CTCPREACTION_NONE", "CTCPs are allowed" },
326 { "CSMSG_CTCPREACTION_KICK", "Kick on disallowed CTCPs" },
327 { "CSMSG_CTCPREACTION_KICKBAN", "Kickban on disallowed CTCPs" },
328 { "CSMSG_CTCPREACTION_SHORTBAN", "Short timed ban on disallowed CTCPs" },
329 { "CSMSG_CTCPREACTION_LONGBAN", "Long timed ban on disallowed CTCPs" },
331 { "CSMSG_BANTIMEOUT_NONE", "Bans will not be removed automatically."},
332 { "CSMSG_BANTIMEOUT_10M", "Bans will be removed after 10 minutes."},
333 { "CSMSG_BANTIMEOUT_2H", "Bans will be removed after 2 hours."},
334 { "CSMSG_BANTIMEOUT_4H", "Bans will be removed after 4 hours."},
335 { "CSMSG_BANTIMEOUT_1D", "Bans will be removed after 24 hours."},
336 { "CSMSG_BANTIMEOUT_1W", "Bans will be removed after 1 week."},
338 { "CSMSG_INVITED_USER", "Invited $b%s$b to join %s." },
339 { "CSMSG_INVITING_YOU_REASON", "$b%s$b invites you to join %s: %s" },
340 { "CSMSG_INVITING_YOU", "$b%s$b invites you to join %s." },
341 { "CSMSG_ALREADY_PRESENT", "%s is already in $b%s$b." },
342 { "CSMSG_YOU_ALREADY_PRESENT", "You are already in $b%s$b." },
343 { "CSMSG_LOW_CHANNEL_ACCESS", "You lack sufficient access in %s to use this command." },
344 { "CSMSG_INFOLINE_TOO_LONG", "Your infoline may not exceed %u characters." },
345 { "CSMSG_BAD_INFOLINE", "You may not use the character \\%03o in your infoline." },
347 { "CSMSG_KICK_DONE", "Kicked $b%s$b from %s." },
348 { "CSMSG_NO_BANS", "No bans found on $b%s$b." },
349 { "CSMSG_BANS_REMOVED", "Removed all channel bans from $b%s$b." },
351 /* Channel userlist */
352 { "CSMSG_ACCESS_ALL_HEADER", "$b%s Users From Level %s To %s$b" },
353 { "CSMSG_ACCESS_SEARCH_HEADER", "$b%s Users From Level %s To %s Matching %s$b" },
354 { "CSMSG_INVALID_ACCESS", "$b%s$b is an invalid access level." },
355 { "CSMSG_CHANGED_ACCESS", "%s now has access $b%s$b (%u) in %s." },
356 { "CSMSG_LAMERS_HEADER", "$bLamers in %s$b" },
358 /* Channel note list */
359 { "CSMSG_NOTELIST_HEADER", "Notes for $b%s$b:" },
360 { "CSMSG_REPLACED_NOTE", "Replaced old $b%s$b note on %s (set by %s): %s" },
361 { "CSMSG_NOTE_FORMAT", "%s (set by %s): %s" },
362 { "CSMSG_NOTELIST_END", "End of notes for $b%s$b." },
363 { "CSMSG_NOTELIST_EMPTY", "There are no (visible) notes for $b%s$b." },
364 { "CSMSG_NO_SUCH_NOTE", "Channel $b%s$b does not have a note named $b%s$b." },
365 { "CSMSG_BAD_NOTE_TYPE", "Note type $b%s$b does not exist." },
366 { "CSMSG_NOTE_SET", "Note $b%s$b set in channel $b%s$b." },
367 { "CSMSG_NOTE_REMOVED", "Note $b%s$b removed in channel $b%s$b." },
368 { "CSMSG_BAD_NOTE_ACCESS", "$b%s$b is not a valid note access type." },
369 { "CSMSG_BAD_MAX_LENGTH", "$b%s$b is not a valid maximum length (must be between 20 and 450 inclusive)." },
370 { "CSMSG_NOTE_MODIFIED", "Note type $b%s$b modified." },
371 { "CSMSG_NOTE_CREATED", "Note type $b%s$b created." },
372 { "CSMSG_NOTE_TYPE_USED", "Note type $b%s$b is in use; give the FORCE argument to delete it." },
373 { "CSMSG_NOTE_DELETED", "Note type $b%s$b deleted." },
375 /* Channel [un]suspension */
376 { "CSMSG_ALREADY_SUSPENDED", "$b%s$b is already suspended." },
377 { "CSMSG_NOT_SUSPENDED", "$b%s$b is not suspended." },
378 { "CSMSG_SUSPENDED", "$b$C$b access to $b%s$b has been temporarily suspended." },
379 { "CSMSG_UNSUSPENDED", "$b$C$b access to $b%s$b has been restored." },
380 { "CSMSG_SUSPEND_NODELETE", "$b%s$b is protected from unregistration, and cannot be suspended." },
381 { "CSMSG_USER_SUSPENDED", "$b%s$b's access to $b%s$b has been suspended." },
382 { "CSMSG_USER_UNSUSPENDED", "$b%s$b's access to $b%s$b has been restored." },
384 /* Access information */
385 { "CSMSG_IS_CHANSERV", "$b$C$b is the $bchannel service bot$b." },
386 { "CSMSG_MYACCESS_SELF_ONLY", "You may only see the list of infolines for yourself (by using $b%s$b with no arguments)." },
387 { "CSMSG_SQUAT_ACCESS", "$b%s$b does not have access to any channels." },
388 { "CSMSG_INFOLINE_LIST", "Showing all channel entries for account $b%s$b:" },
389 { "CSMSG_USER_NO_ACCESS", "%s lacks access to %s." },
390 { "CSMSG_USER_HAS_ACCESS", "%s has $b%s$b access (%d) in %s." },
391 { "CSMSG_HELPER_NO_ACCESS", "%s lacks access to %s but has $bsecurity override$b enabled." },
392 { "CSMSG_HELPER_HAS_ACCESS", "%s has $b%s$b access (%d) in %s and has $bsecurity override$b enabled." },
393 { "CSMSG_LAZY_SMURF_TARGET", "%s is %s ($bIRCOp$b; not logged in)." },
394 { "CSMSG_SMURF_TARGET", "%s is %s ($b%s$b)." },
395 { "CSMSG_LAME_SMURF_TARGET", "%s is an IRC operator." },
397 /* Seen information */
398 { "CSMSG_NEVER_SEEN", "%s has never been seen in $b%s$b." },
399 { "CSMSG_USER_SEEN", "%s was last seen in $b%s$b %s ago." },
400 { "CSMSG_USER_VACATION", "%s is currently on vacation." },
401 { "CSMSG_USER_PRESENT", "%s is in the channel $bright now$b." },
403 /* Names information */
404 { "CSMSG_CHANNEL_NAMES", "Users in $b%s$b:%s" },
405 { "CSMSG_END_NAMES", "End of names in $b%s$b" },
407 /* Channel information */
408 { "CSMSG_CHANNEL_INFO", "$bInformation About %s$b" },
409 { "CSMSG_BAR", "----------------------------------------"},
410 { "CSMSG_CHANNEL_TOPIC", "$bDefault Topic: $b%s" },
411 { "CSMSG_CHANNEL_MODES", "$bMode Lock: $b%s" },
412 { "CSMSG_CHANNEL_NOTE", "$b%s:%*s$b%s" },
413 { "CSMSG_CHANNEL_MAX", "$bRecord Visitors: $b%i" },
414 { "CSMSG_CHANNEL_OWNER", "$bOwner: $b%s" },
415 { "CSMSG_CHANNEL_LAMERS", "$bLamer Count: $b%i" },
416 { "CSMSG_CHANNEL_USERS", "$bTotal User Count: $b%i" },
417 { "CSMSG_CHANNEL_REGISTRAR", "$bRegistrar: $b%s" },
418 { "CSMSG_CHANNEL_SUSPENDED", "$b%s$b is suspended:" },
419 { "CSMSG_CHANNEL_HISTORY", "Suspension history for $b%s$b:" },
420 { "CSMSG_CHANNEL_SUSPENDED_0", " by %s: %s" },
421 { "CSMSG_CHANNEL_SUSPENDED_1", " by %s; expires in %s: %s" },
422 { "CSMSG_CHANNEL_SUSPENDED_2", " by %s; expired %s ago: %s" },
423 { "CSMSG_CHANNEL_SUSPENDED_3", " by %s; revoked %s ago: %s" },
424 { "CSMSG_CHANNEL_SUSPENDED_4", " %s ago by %s: %s" },
425 { "CSMSG_CHANNEL_SUSPENDED_5", " %s ago by %s; expires in %s: %s" },
426 { "CSMSG_CHANNEL_SUSPENDED_6", " %s ago by %s; expired %s ago: %s" },
427 { "CSMSG_CHANNEL_SUSPENDED_7", " %s ago by %s; revoked %s ago: %s" },
428 { "CSMSG_CHANNEL_REGISTERED", "$bRegistered: $b%s ago." },
429 { "CSMSG_CHANNEL_VISITED", "$bVisited: $b%s ago." },
430 { "CSMSG_CHANNEL_END", "---------------End of Info--------------"},
432 { "CSMSG_PEEK_INFO", "$bStatus of %s$b" },
433 { "CSMSG_PEEK_TOPIC", "$bTopic: $b%s" },
434 { "CSMSG_PEEK_MODES", "$bModes: $b%s" },
435 { "CSMSG_PEEK_USERS", "$bTotal users: $b%d" },
436 { "CSMSG_PEEK_OPS", "$bOps:$b" },
437 { "CSMSG_PEEK_NO_OPS", "$bOps: $bNone present" },
438 { "CSMSG_PEEK_END", "-------------End of Status--------------" },
440 /* Network information */
441 { "CSMSG_NETWORK_INFO", "Network Information:" },
442 { "CSMSG_NETWORK_SERVERS", "$bServers: $b%i" },
443 { "CSMSG_NETWORK_USERS", "$bTotal Users: $b%i" },
444 { "CSMSG_NETWORK_LAMERS", "$bTotal Lamer Count: $b%i" },
445 { "CSMSG_NETWORK_CHANUSERS", "$bTotal User Count: $b%i" },
446 { "CSMSG_NETWORK_OPERS", "$bIRC Operators: $b%i" },
447 { "CSMSG_NETWORK_CHANNELS","$bRegistered Channels: $b%i" },
448 { "CSMSG_SERVICES_UPTIME", "$bServices Uptime: $b%s" },
449 { "CSMSG_BURST_LENGTH", "$bLast Burst Length: $b%s" },
452 { "CSMSG_NETWORK_STAFF", "$bOnline Network Staff:$b" },
453 { "CSMSG_STAFF_OPERS", "$bIRC Operators:$b" },
454 { "CSMSG_STAFF_HELPERS", "$bHelpers:$b" },
456 /* Channel searches */
457 { "CSMSG_ACTION_INVALID", "$b%s$b is not a recognized search action." },
458 { "CSMSG_UNVISITED_HEADER", "Showing a maximum of %d channels unvisited for $b%s$b:" },
459 { "CSMSG_UNVISITED_DATA", "%s: $b%s$b" },
460 { "CSMSG_CHANNEL_SEARCH_RESULTS", "$bChannels Found Matching Search$b" },
462 /* Channel configuration */
463 { "CSMSG_INVALID_OPTION", "$b%s$b is not a valid %s option." },
464 { "CSMSG_CHANNEL_OPTIONS", "$bChannel Options for %s$b" },
465 { "CSMSG_CHANNEL_OPTIONS_END", "-------------End of Options-------------" },
466 { "CSMSG_GREETING_TOO_LONG", "Your greeting ($b%d$b characters) must be shorter than $b%d$b characters." },
469 { "CSMSG_USER_OPTIONS", "User Options:" },
470 // { "CSMSG_USER_PROTECTED", "That user is protected." },
473 { "CSMSG_UNF_RESPONSE", "I don't want to be part of your sick fantasies!" },
474 { "CSMSG_PING_RESPONSE", "Pong!" },
475 { "CSMSG_WUT_RESPONSE", "wut" },
476 { "CSMSG_BAD_NUMBER", "$b%s$b is an invalid number. Please use a number greater than 1 with this command." },
477 { "CSMSG_BAD_DIE_FORMAT", "I do not understand $b%s$b. Please use either a single number or standard 4d6+3 format." },
478 { "CSMSG_BAD_DICE_COUNT", "%lu is too many dice. Please use at most %lu." },
479 { "CSMSG_DICE_ROLL", "The total is $b%lu$b from rolling %lud%lu+%lu." },
480 { "CSMSG_DIE_ROLL", "A $b%lu$b shows on the %lu-sided die." },
481 { "CSMSG_HUGGLES_HIM", "\001ACTION huggles %s\001" },
482 { "CSMSG_HUGGLES_YOU", "\001ACTION huggles you\001" },
485 { "CSMSG_EVENT_SEARCH_RESULTS", "$bChannel Events for %s$b" },
486 { "CSMSG_LAST_INVALID", "Invalid argument. must be 1-200" },
490 /* eject_user and unban_user flags */
491 #define ACTION_KICK 0x0001
492 #define ACTION_BAN 0x0002
493 #define ACTION_ADD_LAMER 0x0004
494 #define ACTION_ADD_TIMED_LAMER 0x0008
495 #define ACTION_UNBAN 0x0010
496 #define ACTION_DEL_LAMER 0x0020
498 /* The 40 allows for [+-ntlksimprD] and lots of fudge factor. */
499 #define MODELEN 40 + KEYLEN
503 #define CSFUNC_ARGS user, channel, argc, argv, cmd
505 #define CHANSERV_FUNC(NAME) MODCMD_FUNC(NAME)
506 #define CHANSERV_SYNTAX() svccmd_send_help_brief(user, chanserv, cmd)
507 #define REQUIRE_PARAMS(N) if(argc < (N)) { \
508 reply("MSG_MISSING_PARAMS", argv[0]); \
512 DECLARE_LIST(dnrList
, struct do_not_register
*);
513 DEFINE_LIST(dnrList
, struct do_not_register
*);
515 static int eject_user(struct userNode
*user
, struct chanNode
*channel
, unsigned int argc
, char *argv
[], struct svccmd
*cmd
, int action
);
517 struct userNode
*chanserv
;
520 static dict_t plain_dnrs
, mask_dnrs
, handle_dnrs
;
521 static struct log_type
*CS_LOG
;
522 struct adduserPending
* adduser_pendings
= NULL
;
523 unsigned int adduser_pendings_count
= 0;
527 struct channelList support_channels
;
528 struct mod_chanmode default_modes
;
530 unsigned long db_backup_frequency
;
531 unsigned long channel_expire_frequency
;
532 unsigned long ban_timeout_frequency
;
535 unsigned int adjust_delay
;
536 long channel_expire_delay
;
537 unsigned int nodelete_level
;
539 unsigned int adjust_threshold
;
540 int join_flood_threshold
;
542 unsigned int greeting_length
;
543 unsigned int refresh_period
;
544 unsigned int giveownership_period
;
546 unsigned int max_owned
;
547 unsigned int max_chan_users
;
548 unsigned int max_chan_bans
; /* lamers */
549 unsigned int max_userinfo_length
;
551 struct string_list
*set_shows
;
552 struct string_list
*eightball
;
553 struct string_list
*old_ban_names
;
555 const char *ctcp_short_ban_duration
;
556 const char *ctcp_long_ban_duration
;
558 const char *irc_operator_epithet
;
559 const char *network_helper_epithet
;
560 const char *support_helper_epithet
;
565 struct userNode
*user
;
566 struct userNode
*bot
;
567 struct chanNode
*channel
;
569 unsigned short lowest
;
570 unsigned short highest
;
571 struct userData
**users
;
572 struct helpfile_table table
;
575 enum note_access_type
577 NOTE_SET_CHANNEL_ACCESS
,
578 NOTE_SET_CHANNEL_SETTER
,
582 enum note_visible_type
585 NOTE_VIS_CHANNEL_USERS
,
591 enum note_access_type set_access_type
;
593 unsigned int min_opserv
;
594 unsigned short min_ulevel
;
596 enum note_visible_type visible_type
;
597 unsigned int max_length
;
604 struct note_type
*type
;
605 char setter
[NICKSERV_HANDLE_LEN
+1];
609 static unsigned int registered_channels
;
610 static unsigned int banCount
;
612 static const struct {
615 unsigned short level
;
617 } accessLevels
[] = { /* MUST be orderd less to most! */
618 { "peon", "Peon", UL_PEON
, '+' },
619 { "halfop", "HalfOp", UL_HALFOP
, '%' },
620 { "op", "Op", UL_OP
, '@' },
621 { "manager", "Manager", UL_MANAGER
, '%' },
622 { "coowner", "Coowner", UL_COOWNER
, '*' },
623 { "owner", "Owner", UL_OWNER
, '!' },
624 { "helper", "BUG:", UL_HELPER
, 'X' }
627 /* If you change this, change the enum in chanserv.h also, or stack smashing will commence. */
628 static const struct {
631 unsigned short default_value
;
632 unsigned int old_idx
;
633 unsigned int old_flag
;
634 unsigned short flag_value
;
636 { "CSMSG_SET_ENFOPS", "enfops", 300, 1, 0, 0 },
637 { "CSMSG_SET_ENFHALFOPS", "enfhalfops", 300, 1, 0, 0 },
638 { "CSMSG_SET_ENFMODES", "enfmodes", 200, 3, 0, 0 },
639 { "CSMSG_SET_ENFTOPIC", "enftopic", 200, 4, 0, 0 },
640 { "CSMSG_SET_PUBCMD", "pubcmd", 0, 5, 0, 0 },
641 { "CSMSG_SET_SETTERS", "setters", 400, 7, 0, 0 },
642 { "CSMSG_SET_USERINFO", "userinfo", 1, ~0, CHANNEL_INFO_LINES
, 1 },
643 { "CSMSG_SET_INVITEME", "inviteme", 1, ~0, CHANNEL_PEON_INVITE
, 200 },
644 { "CSMSG_SET_TOPICSNARF", "topicsnarf", 501, ~0, CHANNEL_TOPIC_SNARF
, 1 }
647 struct charOptionValues
{
650 } automodeValues
[] = {
651 { 'n', "CSMSG_AUTOMODE_NONE" },
652 { 'y', "CSMSG_AUTOMODE_NORMAL" },
653 { 'v', "CSMSG_AUTOMODE_VOICE" },
654 { 'h', "CSMSG_AUTOMODE_HOP" },
655 { 'o', "CSMSG_AUTOMODE_OP" },
656 { 'm', "CSMSG_AUTOMODE_MUTE" }
657 }, protectValues
[] = {
658 { 'a', "CSMSG_PROTECT_ALL" },
659 { 'e', "CSMSG_PROTECT_EQUAL" },
660 { 'l', "CSMSG_PROTECT_LOWER" },
661 { 'n', "CSMSG_PROTECT_NONE" }
663 { 'd', "CSMSG_TOYS_DISABLED" },
664 { 'n', "CSMSG_TOYS_PRIVATE" },
665 { 'p', "CSMSG_TOYS_PUBLIC" }
666 }, topicRefreshValues
[] = {
667 { 'n', "CSMSG_TOPICREFRESH_NEVER" },
668 { '1', "CSMSG_TOPICREFRESH_3_HOURS" },
669 { '2', "CSMSG_TOPICREFRESH_6_HOURS" },
670 { '3', "CSMSG_TOPICREFRESH_12_HOURS" },
671 { '4', "CSMSG_TOPICREFRESH_24_HOURS" }
672 }, ctcpReactionValues
[] = {
673 { 'n', "CSMSG_CTCPREACTION_NONE" },
674 { 'k', "CSMSG_CTCPREACTION_KICK" },
675 { 'b', "CSMSG_CTCPREACTION_KICKBAN" },
676 { 't', "CSMSG_CTCPREACTION_SHORTBAN" },
677 { 'T', "CSMSG_CTCPREACTION_LONGBAN" }
678 }, banTimeoutValues
[] = {
679 { '0', "CSMSG_BANTIMEOUT_NONE" },
680 { '1', "CSMSG_BANTIMEOUT_10M" },
681 { '2', "CSMSG_BANTIMEOUT_2H" },
682 { '3', "CSMSG_BANTIMEOUT_4H" },
683 { '4', "CSMSG_BANTIMEOUT_1D" },
684 { '5', "CSMSG_BANTIMEOUT_1W" }
687 static const struct {
691 unsigned int old_idx
;
693 struct charOptionValues
*values
;
695 { "CSMSG_SET_AUTOMODE", "automode", 'y', 99, ArrayLength(automodeValues
), automodeValues
},
696 { "CSMSG_SET_PROTECT", "protect", 'l', 0, ArrayLength(protectValues
), protectValues
},
697 { "CSMSG_SET_TOYS", "toys", 'p', 6, ArrayLength(toysValues
), toysValues
},
698 { "CSMSG_SET_TOPICREFRESH", "topicrefresh", 'n', 8, ArrayLength(topicRefreshValues
), topicRefreshValues
},
699 { "CSMSG_SET_CTCPREACTION", "ctcpreaction", 'n', 10, ArrayLength(ctcpReactionValues
), ctcpReactionValues
},
700 { "CSMSG_SET_BANTIMEOUT", "bantimeout", '0', 11, ArrayLength(banTimeoutValues
), banTimeoutValues
}
703 struct userData
*helperList
;
704 struct chanData
*channelList
;
705 static struct module *chanserv_module
;
706 static unsigned int userCount
;
707 unsigned int chanserv_read_version
= 0; /* db version control */
709 #define CHANSERV_DB_VERSION 2
711 #define GetChannelUser(channel, handle) _GetChannelUser(channel, handle, 1, 0)
712 #define GetChannelAccess(channel, handle) _GetChannelUser(channel, handle, 0, 0)
713 #define GetTrueChannelAccess(channel, handle) _GetChannelUser(channel, handle, 0, 1)
716 user_level_from_name(const char *name
, unsigned short clamp_level
)
718 unsigned int level
= 0, ii
;
720 level
= strtoul(name
, NULL
, 10);
721 else for(ii
= 0; (ii
< ArrayLength(accessLevels
)) && !level
; ++ii
)
722 if(!irccasecmp(name
, accessLevels
[ii
].name
))
723 level
= accessLevels
[ii
].level
;
724 if(level
> clamp_level
)
730 user_level_name_from_level(int level
)
738 for(ii
= 0; (ii
< ArrayLength(accessLevels
)); ii
++)
739 if(level
>= accessLevels
[ii
].level
)
740 highest
= accessLevels
[ii
].title
;
746 parse_level_range(unsigned short *minl
, unsigned short *maxl
, const char *arg
)
749 *minl
= strtoul(arg
, &sep
, 10);
757 *maxl
= strtoul(sep
+1, &sep
, 10);
765 _GetChannelUser(struct chanData
*channel
, struct handle_info
*handle
, int override
, int allow_suspended
)
767 struct userData
*uData
, **head
;
769 if(!channel
|| !handle
)
772 if(override
&& HANDLE_FLAGGED(handle
, HELPING
)
773 && ((handle
->opserv_level
>= chanserv_conf
.nodelete_level
) || !IsProtected(channel
)))
775 for(uData
= helperList
;
776 uData
&& uData
->handle
!= handle
;
777 uData
= uData
->next
);
781 uData
= calloc(1, sizeof(struct userData
));
782 uData
->handle
= handle
;
784 uData
->access
= UL_HELPER
;
790 uData
->next
= helperList
;
792 helperList
->prev
= uData
;
800 for(uData
= channel
->users
; uData
; uData
= uData
->next
)
801 if((uData
->handle
== handle
) && (allow_suspended
|| !IsUserSuspended(uData
)))
804 head
= &(channel
->users
);
807 if(uData
&& (uData
!= *head
))
809 /* Shuffle the user to the head of whatever list he was in. */
811 uData
->next
->prev
= uData
->prev
;
813 uData
->prev
->next
= uData
->next
;
819 (**head
).prev
= uData
;
826 /* Returns non-zero if user has at least the minimum access.
827 * exempt_owner is set when handling !set, so the owner can set things
830 int check_user_level(struct chanNode
*channel
, struct userNode
*user
, enum levelOption opt
, int allow_override
, int exempt_owner
)
832 struct userData
*uData
;
833 struct chanData
*cData
= channel
->channel_info
;
834 unsigned short minimum
= cData
->lvlOpts
[opt
];
837 uData
= _GetChannelUser(cData
, user
->handle_info
, allow_override
, 0);
840 if(minimum
<= uData
->access
)
842 if((minimum
> UL_OWNER
) && (uData
->access
== UL_OWNER
) && exempt_owner
)
847 /* Scan for other users authenticated to the same handle
848 still in the channel. If so, keep them listed as present.
850 user is optional, if not null, it skips checking that userNode
851 (for the handle_part function) */
853 scan_user_presence(struct userData
*uData
, struct userNode
*user
)
857 if(IsSuspended(uData
->channel
)
858 || IsUserSuspended(uData
)
859 || !(mn
= find_handle_in_channel(uData
->channel
->channel
, uData
->handle
, user
)))
871 chanserv_ctcp_check(struct userNode
*user
, struct chanNode
*channel
, char *text
, UNUSED_ARG(struct userNode
*bot
))
873 unsigned int eflags
, argc
;
875 static char *bad_ctcp_reason
= "CTCPs to this channel are forbidden.";
877 /* Bail early if channel is inactive or doesn't restrict CTCPs, or sender is a service */
878 if(!channel
->channel_info
879 || IsSuspended(channel
->channel_info
)
881 || !ircncasecmp(text
, "ACTION ", 7))
883 /* We dont punish people we know -Rubin
884 * * Figure out the minimum level needed to CTCP the channel *
886 * if(check_user_level(channel, user, lvlCTCPUsers, 1, 0))
889 /* If they are a user of the channel, they are exempt */
890 if(_GetChannelUser(channel
->channel_info
, user
->handle_info
, 0, 0))
892 /* We need to enforce against them; do so. */
895 argv
[1] = user
->nick
;
897 if(GetUserMode(channel
, user
))
898 eflags
|= ACTION_KICK
;
899 switch(channel
->channel_info
->chOpts
[chCTCPReaction
]) {
900 default: case 'n': return;
902 eflags
|= ACTION_KICK
;
905 eflags
|= ACTION_BAN
;
908 eflags
|= ACTION_BAN
| ACTION_ADD_LAMER
| ACTION_ADD_TIMED_LAMER
;
909 argv
[argc
++] = (char*)chanserv_conf
.ctcp_short_ban_duration
;
912 eflags
|= ACTION_BAN
| ACTION_ADD_LAMER
| ACTION_ADD_TIMED_LAMER
;
913 argv
[argc
++] = (char*)chanserv_conf
.ctcp_long_ban_duration
;
916 argv
[argc
++] = bad_ctcp_reason
;
917 eject_user(chanserv
, channel
, argc
, argv
, NULL
, eflags
);
921 chanserv_create_note_type(const char *name
)
923 struct note_type
*ntype
= calloc(1, sizeof(*ntype
) + strlen(name
));
924 strcpy(ntype
->name
, name
);
926 dict_insert(note_types
, ntype
->name
, ntype
);
931 chanserv_deref_note_type(void *data
)
933 struct note_type
*ntype
= data
;
935 if(--ntype
->refs
> 0)
941 chanserv_flush_note_type(struct note_type
*ntype
)
943 struct chanData
*cData
;
944 for(cData
= channelList
; cData
; cData
= cData
->next
)
945 dict_remove(cData
->notes
, ntype
->name
);
949 chanserv_truncate_notes(struct note_type
*ntype
)
951 struct chanData
*cData
;
953 unsigned int size
= sizeof(*note
) + ntype
->max_length
;
955 for(cData
= channelList
; cData
; cData
= cData
->next
) {
956 note
= dict_find(cData
->notes
, ntype
->name
, NULL
);
959 if(strlen(note
->note
) <= ntype
->max_length
)
961 dict_remove2(cData
->notes
, ntype
->name
, 1);
962 note
= realloc(note
, size
);
963 note
->note
[ntype
->max_length
] = 0;
964 dict_insert(cData
->notes
, ntype
->name
, note
);
968 static int note_type_visible_to_user(struct chanData
*channel
, struct note_type
*ntype
, struct userNode
*user
);
971 chanserv_add_channel_note(struct chanData
*channel
, struct note_type
*type
, const char *setter
, const char *text
)
974 unsigned int len
= strlen(text
);
976 if(len
> type
->max_length
) len
= type
->max_length
;
977 note
= calloc(1, sizeof(*note
) + len
);
979 strncpy(note
->setter
, setter
, sizeof(note
->setter
)-1);
980 memcpy(note
->note
, text
, len
);
982 dict_insert(channel
->notes
, type
->name
, note
);
988 chanserv_free_note(void *data
)
990 struct note
*note
= data
;
992 chanserv_deref_note_type(note
->type
);
993 assert(note
->type
->refs
> 0); /* must use delnote to remove the type */
997 static MODCMD_FUNC(cmd_createnote
) {
998 struct note_type
*ntype
;
999 unsigned int arg
= 1, existed
= 0, max_length
;
1001 if((ntype
= dict_find(note_types
, argv
[1], NULL
)))
1004 ntype
= chanserv_create_note_type(argv
[arg
]);
1005 if(!irccasecmp(argv
[++arg
], "privileged"))
1008 ntype
->set_access_type
= NOTE_SET_PRIVILEGED
;
1009 ntype
->set_access
.min_opserv
= strtoul(argv
[arg
], NULL
, 0);
1011 else if(!irccasecmp(argv
[arg
], "channel"))
1013 unsigned short ulvl
= user_level_from_name(argv
[++arg
], UL_OWNER
);
1016 reply("CSMSG_INVALID_ACCESS", argv
[arg
]);
1019 ntype
->set_access_type
= NOTE_SET_CHANNEL_ACCESS
;
1020 ntype
->set_access
.min_ulevel
= ulvl
;
1022 else if(!irccasecmp(argv
[arg
], "setter"))
1024 ntype
->set_access_type
= NOTE_SET_CHANNEL_SETTER
;
1028 reply("CSMSG_BAD_NOTE_ACCESS", argv
[arg
]);
1032 if(!irccasecmp(argv
[++arg
], "privileged"))
1033 ntype
->visible_type
= NOTE_VIS_PRIVILEGED
;
1034 else if(!irccasecmp(argv
[arg
], "channel_users"))
1035 ntype
->visible_type
= NOTE_VIS_CHANNEL_USERS
;
1036 else if(!irccasecmp(argv
[arg
], "all"))
1037 ntype
->visible_type
= NOTE_VIS_ALL
;
1039 reply("CSMSG_BAD_NOTE_ACCESS", argv
[arg
]);
1043 if((arg
+1) >= argc
) {
1044 reply("MSG_MISSING_PARAMS", argv
[0]);
1047 max_length
= strtoul(argv
[++arg
], NULL
, 0);
1048 if(max_length
< 20 || max_length
> 450)
1050 reply("CSMSG_BAD_MAX_LENGTH", argv
[arg
]);
1053 if(existed
&& (max_length
< ntype
->max_length
))
1055 ntype
->max_length
= max_length
;
1056 chanserv_truncate_notes(ntype
);
1058 ntype
->max_length
= max_length
;
1061 reply("CSMSG_NOTE_MODIFIED", ntype
->name
);
1063 reply("CSMSG_NOTE_CREATED", ntype
->name
);
1068 dict_remove(note_types
, ntype
->name
);
1072 static MODCMD_FUNC(cmd_removenote
) {
1073 struct note_type
*ntype
;
1076 ntype
= dict_find(note_types
, argv
[1], NULL
);
1077 force
= (argc
> 2) && !irccasecmp(argv
[2], "force");
1080 reply("CSMSG_BAD_NOTE_TYPE", argv
[1]);
1087 reply("CSMSG_NOTE_TYPE_USED", ntype
->name
);
1090 chanserv_flush_note_type(ntype
);
1092 dict_remove(note_types
, argv
[1]);
1093 reply("CSMSG_NOTE_DELETED", argv
[1]);
1098 mode_lock_violated(const struct mod_chanmode
*orig
, const struct mod_chanmode
*change
)
1102 if(orig
->modes_set
& change
->modes_clear
)
1104 if(orig
->modes_clear
& change
->modes_set
)
1106 if((orig
->modes_set
& MODE_KEY
) && (change
->modes_set
& MODE_KEY
)
1107 && strcmp(orig
->new_key
, change
->new_key
))
1109 if((orig
->modes_set
& MODE_LIMIT
) && (change
->modes_set
& MODE_LIMIT
)
1110 && (orig
->new_limit
!= change
->new_limit
))
1115 static char max_length_text
[MAXLEN
+1][16];
1117 static struct helpfile_expansion
1118 chanserv_expand_variable(const char *variable
)
1120 struct helpfile_expansion exp
;
1122 if(!irccasecmp(variable
, "notes"))
1125 exp
.type
= HF_TABLE
;
1126 exp
.value
.table
.length
= 1;
1127 exp
.value
.table
.width
= 3;
1128 exp
.value
.table
.flags
= 0;
1129 exp
.value
.table
.contents
= calloc(dict_size(note_types
)+1, sizeof(char**));
1130 exp
.value
.table
.contents
[0] = calloc(exp
.value
.table
.width
, sizeof(char*));
1131 exp
.value
.table
.contents
[0][0] = "Note Type";
1132 exp
.value
.table
.contents
[0][1] = "Visibility";
1133 exp
.value
.table
.contents
[0][2] = "Max Length";
1134 for(it
=dict_first(note_types
); it
; it
=iter_next(it
))
1136 struct note_type
*ntype
= iter_data(it
);
1139 if(!note_type_visible_to_user(NULL
, ntype
, message_dest
)) continue;
1140 row
= exp
.value
.table
.length
++;
1141 exp
.value
.table
.contents
[row
] = calloc(exp
.value
.table
.width
, sizeof(char*));
1142 exp
.value
.table
.contents
[row
][0] = ntype
->name
;
1143 exp
.value
.table
.contents
[row
][1] = (ntype
->visible_type
== NOTE_VIS_ALL
) ? "all" :
1144 (ntype
->visible_type
== NOTE_VIS_CHANNEL_USERS
) ? "chan users" :
1146 if(!max_length_text
[ntype
->max_length
][0])
1147 snprintf(max_length_text
[ntype
->max_length
], sizeof(max_length_text
[ntype
->max_length
]), "%u", ntype
->max_length
);
1148 exp
.value
.table
.contents
[row
][2] = max_length_text
[ntype
->max_length
];
1153 exp
.type
= HF_STRING
;
1154 exp
.value
.str
= NULL
;
1158 static struct chanData
*
1159 register_channel(struct chanNode
*cNode
, char *registrar
)
1161 struct chanData
*channel
;
1162 enum levelOption lvlOpt
;
1163 enum charOption chOpt
;
1165 channel
= calloc(1, sizeof(struct chanData
));
1167 channel
->notes
= dict_new();
1168 dict_set_free_data(channel
->notes
, chanserv_free_note
);
1170 channel
->registrar
= strdup(registrar
);
1171 channel
->registered
= now
;
1172 channel
->visited
= now
;
1173 channel
->limitAdjusted
= now
;
1174 channel
->ownerTransfer
= now
;
1175 channel
->flags
= CHANNEL_DEFAULT_FLAGS
;
1176 for(lvlOpt
= 0; lvlOpt
< NUM_LEVEL_OPTIONS
; ++lvlOpt
)
1177 channel
->lvlOpts
[lvlOpt
] = levelOptions
[lvlOpt
].default_value
;
1178 for(chOpt
= 0; chOpt
< NUM_CHAR_OPTIONS
; ++chOpt
)
1179 channel
->chOpts
[chOpt
] = charOptions
[chOpt
].default_value
;
1181 channel
->prev
= NULL
;
1182 channel
->next
= channelList
;
1185 channelList
->prev
= channel
;
1186 channelList
= channel
;
1187 registered_channels
++;
1189 channel
->channel
= cNode
;
1191 cNode
->channel_info
= channel
;
1196 static struct userData
*
1197 add_channel_user(struct chanData
*channel
, struct handle_info
*handle
, unsigned short access
, time_t seen
, const char *info
)
1199 struct userData
*ud
;
1201 if(access
> UL_OWNER
)
1204 ud
= calloc(1, sizeof(*ud
));
1205 ud
->channel
= channel
;
1206 ud
->handle
= handle
;
1208 ud
->access
= access
;
1209 ud
->info
= info
? strdup(info
) : NULL
;
1212 ud
->next
= channel
->users
;
1214 channel
->users
->prev
= ud
;
1215 channel
->users
= ud
;
1217 channel
->userCount
++;
1221 ud
->u_next
= ud
->handle
->channels
;
1223 ud
->u_next
->u_prev
= ud
;
1224 ud
->handle
->channels
= ud
;
1226 ud
->flags
= USER_FLAGS_DEFAULT
;
1230 static void unregister_channel(struct chanData
*channel
, const char *reason
);
1233 del_channel_user(struct userData
*user
, int do_gc
)
1235 struct chanData
*channel
= user
->channel
;
1237 channel
->userCount
--;
1241 user
->prev
->next
= user
->next
;
1243 channel
->users
= user
->next
;
1245 user
->next
->prev
= user
->prev
;
1248 user
->u_prev
->u_next
= user
->u_next
;
1250 user
->handle
->channels
= user
->u_next
;
1252 user
->u_next
->u_prev
= user
->u_prev
;
1256 if(do_gc
&& !channel
->users
&& !IsProtected(channel
))
1257 unregister_channel(channel
, "lost all users.");
1260 static struct adduserPending
*
1261 add_adduser_pending(struct chanNode
*channel
, struct userNode
*user
, int level
)
1263 struct adduserPending
*ap
;
1264 ap
= calloc(1,sizeof(struct adduserPending
));
1265 ap
->channel
= channel
;
1268 ap
->created
= time(NULL
);
1270 /* ap->prev defaults to NULL already.. */
1271 ap
->next
= adduser_pendings
;
1272 if(adduser_pendings
)
1273 adduser_pendings
->prev
= ap
;
1274 adduser_pendings
= ap
;
1275 adduser_pendings_count
++;
1280 del_adduser_pending(struct adduserPending
*ap
)
1283 ap
->prev
->next
= ap
->next
;
1285 adduser_pendings
= ap
->next
;
1288 ap
->next
->prev
= ap
->prev
;
1292 static void expire_adduser_pending();
1294 /* find_adduser_pending(channel, user) will find an arbitrary record
1295 * from user, channel, or user and channel.
1296 * if user or channel are NULL, they will match any records.
1298 static struct adduserPending
*
1299 find_adduser_pending(struct chanNode
*channel
, struct userNode
*user
)
1301 struct adduserPending
*ap
;
1303 expire_adduser_pending(); /* why not here.. */
1305 if(!channel
&& !user
) /* 2 nulls matches all */
1306 return(adduser_pendings
);
1307 for(ap
= adduser_pendings
;ap
;ap
= ap
->next
)
1309 if((channel
== ap
->channel
&& (user
== NULL
|| user
== ap
->user
)) || (user
==ap
->user
&& channel
==NULL
))
1316 /* Remove all pendings for a user or channel
1318 * called in nickserv.c DelUser() and proto-* unregister_channel()
1321 wipe_adduser_pending(struct chanNode
*channel
, struct userNode
*user
)
1323 struct adduserPending
*ap
;
1325 /* So this is a bit wastefull, i hate dealing with linked lists.
1326 * if its a problem we'll rewrite it right */
1327 while((ap
= find_adduser_pending(channel
, user
))) {
1328 del_adduser_pending(ap
);
1332 /* Called from nickserv.c cmd_auth after someone auths */
1334 process_adduser_pending(struct userNode
*user
)
1336 struct adduserPending
*ap
;
1337 if(!user
->handle_info
)
1338 return; /* not associated with an account */
1339 while((ap
= find_adduser_pending(NULL
, user
)))
1341 struct userData
*actee
;
1342 if(GetTrueChannelAccess(ap
->channel
->channel_info
, ap
->user
->handle_info
))
1344 /* Already on the userlist. do nothing*/
1348 actee
= add_channel_user(ap
->channel
->channel_info
, ap
->user
->handle_info
, ap
->level
, 0, NULL
);
1349 scan_user_presence(actee
, NULL
);
1351 del_adduser_pending(ap
);
1356 expire_adduser_pending()
1358 struct adduserPending
*ap
, *ap_next
;
1359 ap
= adduser_pendings
;
1362 if((ap
->created
+ ADDUSER_PENDING_EXPIRE
) < time(NULL
))
1364 ap_next
= ap
->next
; /* save next */
1365 del_adduser_pending(ap
); /* free and relink */
1366 ap
= ap_next
; /* advance */
1373 static void expire_ban(void *data
);
1375 static struct banData
*
1376 add_channel_ban(struct chanData
*channel
, const char *mask
, char *owner
, time_t set
, time_t triggered
, time_t expires
, char *reason
)
1379 unsigned int ii
, l1
, l2
;
1384 bd
= malloc(sizeof(struct banData
));
1386 bd
->channel
= channel
;
1388 bd
->triggered
= triggered
;
1389 bd
->expires
= expires
;
1391 for(ii
= 0; ii
< chanserv_conf
.old_ban_names
->used
; ++ii
)
1393 extern const char *hidden_host_suffix
;
1394 const char *old_name
= chanserv_conf
.old_ban_names
->list
[ii
];
1398 l2
= strlen(old_name
);
1401 if(irccasecmp(mask
+ l1
- l2
, old_name
))
1403 new_mask
= alloca(MAXLEN
);
1404 sprintf(new_mask
, "%.*s%s", (int)(l1
-l2
), mask
, hidden_host_suffix
);
1407 safestrncpy(bd
->mask
, mask
, sizeof(bd
->mask
));
1409 safestrncpy(bd
->owner
, owner
, sizeof(bd
->owner
));
1410 bd
->reason
= strdup(reason
);
1413 timeq_add(expires
, expire_ban
, bd
);
1416 bd
->next
= channel
->bans
; /* lamers */
1418 channel
->bans
->prev
= bd
;
1420 channel
->banCount
++;
1427 del_channel_ban(struct banData
*ban
)
1429 ban
->channel
->banCount
--;
1433 ban
->prev
->next
= ban
->next
;
1435 ban
->channel
->bans
= ban
->next
;
1438 ban
->next
->prev
= ban
->prev
;
1441 timeq_del(0, expire_ban
, ban
, TIMEQ_IGNORE_WHEN
);
1450 expire_ban(void *data
) /* lamer.. */
1452 struct banData
*bd
= data
;
1453 if(!IsSuspended(bd
->channel
))
1455 struct banList bans
;
1456 struct mod_chanmode change
;
1458 bans
= bd
->channel
->channel
->banlist
;
1459 mod_chanmode_init(&change
);
1460 for(ii
=0; ii
<bans
.used
; ii
++)
1462 if(!strcmp(bans
.list
[ii
]->ban
, bd
->mask
))
1465 change
.args
[0].mode
= MODE_REMOVE
|MODE_BAN
;
1466 change
.args
[0].u
.hostmask
= bd
->mask
;
1467 mod_chanmode_announce(chanserv
, bd
->channel
->channel
, &change
);
1473 del_channel_ban(bd
);
1476 static void chanserv_expire_suspension(void *data
);
1479 unregister_channel(struct chanData
*channel
, const char *reason
)
1481 struct mod_chanmode change
;
1482 char msgbuf
[MAXLEN
];
1484 /* After channel unregistration, the following must be cleaned
1486 - Channel information.
1488 - Channel bans. (lamers)
1489 - Channel suspension data.
1490 - adduser_pending data.
1491 - Timeq entries. (Except timed bans, which are handled elsewhere.)
1497 timeq_del(0, NULL
, channel
, TIMEQ_IGNORE_FUNC
| TIMEQ_IGNORE_WHEN
);
1501 mod_chanmode_init(&change
);
1502 change
.modes_clear
|= MODE_REGISTERED
;
1503 mod_chanmode_announce(chanserv
, channel
->channel
, &change
);
1506 wipe_adduser_pending(channel
->channel
, NULL
);
1508 while(channel
->users
)
1509 del_channel_user(channel
->users
, 0);
1511 while(channel
->bans
)
1512 del_channel_ban(channel
->bans
);
1514 free(channel
->topic
);
1515 free(channel
->registrar
);
1516 free(channel
->greeting
);
1517 free(channel
->user_greeting
);
1518 free(channel
->topic_mask
);
1521 channel
->prev
->next
= channel
->next
;
1523 channelList
= channel
->next
;
1526 channel
->next
->prev
= channel
->prev
;
1528 if(channel
->suspended
)
1530 struct chanNode
*cNode
= channel
->channel
;
1531 struct suspended
*suspended
, *next_suspended
;
1533 for(suspended
= channel
->suspended
; suspended
; suspended
= next_suspended
)
1535 next_suspended
= suspended
->previous
;
1536 free(suspended
->suspender
);
1537 free(suspended
->reason
);
1538 if(suspended
->expires
)
1539 timeq_del(suspended
->expires
, chanserv_expire_suspension
, suspended
, 0);
1544 cNode
->channel_info
= NULL
;
1546 channel
->channel
->channel_info
= NULL
;
1548 dict_delete(channel
->notes
);
1549 sprintf(msgbuf
, "%s %s", channel
->channel
->name
, reason
);
1550 if(!IsSuspended(channel
))
1551 DelChannelUser(chanserv
, channel
->channel
, msgbuf
, 0);
1552 global_message(MESSAGE_RECIPIENT_OPERS
| MESSAGE_RECIPIENT_HELPERS
, msgbuf
);
1553 UnlockChannel(channel
->channel
);
1555 registered_channels
--;
1559 expire_channels(UNUSED_ARG(void *data
))
1561 struct chanData
*channel
, *next
;
1562 struct userData
*user
;
1563 char delay
[INTERVALLEN
], reason
[INTERVALLEN
+ 64];
1565 intervalString(delay
, chanserv_conf
.channel_expire_delay
, NULL
);
1566 sprintf(reason
, "Channel registration automatically expired after %s of disuse.", delay
);
1568 for(channel
= channelList
; channel
; channel
= next
)
1570 next
= channel
->next
;
1572 /* See if the channel can be expired. */
1573 if(((now
- channel
->visited
) <= chanserv_conf
.channel_expire_delay
)
1574 || IsProtected(channel
))
1577 /* Make sure there are no high-ranking users still in the channel. */
1578 for(user
=channel
->users
; user
; user
=user
->next
)
1579 if(user
->present
&& (user
->access
>= UL_PRESENT
))
1584 /* Unregister the channel */
1585 log_module(CS_LOG
, LOG_INFO
, "(%s) Channel registration expired.", channel
->channel
->name
);
1586 unregister_channel(channel
, "registration expired.");
1589 if(chanserv_conf
.channel_expire_frequency
)
1590 timeq_add(now
+ chanserv_conf
.channel_expire_frequency
, expire_channels
, NULL
);
1594 protect_user(const struct userNode
*victim
, const struct userNode
*aggressor
, struct chanData
*channel
)
1596 char protect
= channel
->chOpts
[chProtect
];
1597 struct userData
*cs_victim
, *cs_aggressor
;
1599 /* Don't protect if no one is to be protected, someone is attacking
1600 himself, or if the aggressor is an IRC Operator. */
1601 if(protect
== 'n' || victim
== aggressor
/* Opers dont get special treatment :/ || IsOper(aggressor) */)
1604 /* Don't protect if the victim isn't authenticated (because they
1605 can't be a channel user), unless we are to protect non-users
1607 cs_victim
= GetChannelAccess(channel
, victim
->handle_info
);
1608 if(protect
!= 'a' && !cs_victim
)
1611 /* Protect if the aggressor isn't a user because at this point,
1612 the aggressor can only be less than or equal to the victim. */
1613 cs_aggressor
= GetChannelAccess(channel
, aggressor
->handle_info
);
1617 /* If the aggressor was a user, then the victim can't be helped. */
1624 if(cs_victim
->access
> cs_aggressor
->access
)
1629 if(cs_victim
->access
>= cs_aggressor
->access
)
1638 validate_op(struct userNode
*user
, struct chanNode
*channel
, struct userNode
*victim
)
1640 struct chanData
*cData
= channel
->channel_info
;
1641 struct userData
*cs_victim
;
1643 if((!(cs_victim
= GetChannelUser(cData
, victim
->handle_info
))
1644 || (cs_victim
->access
< UL_OP
/* cData->lvlOpts[lvlGiveOps]*/))
1645 && !check_user_level(channel
, user
, lvlEnfOps
, 0, 0))
1647 send_message(user
, chanserv
, "CSMSG_OPBY_LOCKED");
1655 validate_halfop(struct userNode
*user
, struct chanNode
*channel
, struct userNode
*victim
)
1657 struct chanData
*cData
= channel
->channel_info
;
1658 struct userData
*cs_victim
;
1660 if((!(cs_victim
= GetChannelUser(cData
, victim
->handle_info
))
1661 || (cs_victim
->access
< UL_HALFOP
/* cData->lvlOpts[lvlGiveHalfOps] */))
1662 && !check_user_level(channel
, user
, lvlEnfHalfOps
, 0, 0))
1664 send_message(user
, chanserv
, "CSMSG_HOPBY_LOCKED");
1673 validate_deop(struct userNode
*user
, struct chanNode
*channel
, struct userNode
*victim
)
1675 if(IsService(victim
))
1677 send_message(user
, chanserv
, "MSG_SERVICE_IMMUNE", victim
->nick
);
1681 if(protect_user(victim
, user
, channel
->channel_info
))
1683 send_message(user
, chanserv
, "CSMSG_USER_PROTECTED", victim
->nick
);
1691 validate_dehop(struct userNode
*user
, struct chanNode
*channel
, struct userNode
*victim
)
1693 if(IsService(victim
))
1695 send_message(user
, chanserv
, "MSG_SERVICE_IMMUNE", victim
->nick
);
1699 if(protect_user(victim
, user
, channel
->channel_info
))
1701 send_message(user
, chanserv
, "CSMSG_USER_PROTECTED", victim
->nick
);
1708 static struct do_not_register
*
1709 chanserv_add_dnr(const char *chan_name
, const char *setter
, const char *reason
)
1711 struct do_not_register
*dnr
= calloc(1, sizeof(*dnr
)+strlen(reason
));
1712 safestrncpy(dnr
->chan_name
, chan_name
, sizeof(dnr
->chan_name
));
1713 safestrncpy(dnr
->setter
, setter
, sizeof(dnr
->setter
));
1714 strcpy(dnr
->reason
, reason
);
1716 if(dnr
->chan_name
[0] == '*')
1717 dict_insert(handle_dnrs
, dnr
->chan_name
+1, dnr
);
1718 else if(strpbrk(dnr
->chan_name
, "*?"))
1719 dict_insert(mask_dnrs
, dnr
->chan_name
, dnr
);
1721 dict_insert(plain_dnrs
, dnr
->chan_name
, dnr
);
1725 static struct dnrList
1726 chanserv_find_dnrs(const char *chan_name
, const char *handle
)
1728 struct dnrList list
;
1730 struct do_not_register
*dnr
;
1732 dnrList_init(&list
);
1733 if(handle
&& (dnr
= dict_find(handle_dnrs
, handle
, NULL
)))
1734 dnrList_append(&list
, dnr
);
1735 if(chan_name
&& (dnr
= dict_find(plain_dnrs
, chan_name
, NULL
)))
1736 dnrList_append(&list
, dnr
);
1738 for(it
= dict_first(mask_dnrs
); it
; it
= iter_next(it
))
1739 if(match_ircglob(chan_name
, iter_key(it
)))
1740 dnrList_append(&list
, iter_data(it
));
1745 chanserv_show_dnrs(struct userNode
*user
, struct svccmd
*cmd
, const char *chan_name
, const char *handle
)
1747 struct dnrList list
;
1748 struct do_not_register
*dnr
;
1750 char buf
[INTERVALLEN
];
1752 list
= chanserv_find_dnrs(chan_name
, handle
);
1753 for(ii
= 0; (ii
< list
.used
) && (ii
< 10); ++ii
)
1755 dnr
= list
.list
[ii
];
1758 strftime(buf
, sizeof(buf
), "%Y %b %d", localtime(&dnr
->set
));
1759 reply("CSMSG_DNR_INFO_SET", dnr
->chan_name
, buf
, dnr
->setter
, dnr
->reason
);
1762 reply("CSMSG_DNR_INFO", dnr
->chan_name
, dnr
->setter
, dnr
->reason
);
1765 reply("CSMSG_MORE_DNRS", list
.used
- ii
);
1770 struct do_not_register
*
1771 chanserv_is_dnr(const char *chan_name
, struct handle_info
*handle
)
1773 struct do_not_register
*dnr
;
1776 if(handle
&& (dnr
= dict_find(handle_dnrs
, handle
->handle
, NULL
)))
1780 if((dnr
= dict_find(plain_dnrs
, chan_name
, NULL
)))
1782 for(it
= dict_first(mask_dnrs
); it
; it
= iter_next(it
))
1783 if(match_ircglob(chan_name
, iter_key(it
)))
1784 return iter_data(it
);
1789 static CHANSERV_FUNC(cmd_noregister
)
1792 struct do_not_register
*dnr
;
1793 char buf
[INTERVALLEN
];
1794 unsigned int matches
;
1800 reply("CSMSG_DNR_SEARCH_RESULTS");
1803 for(it
= dict_first(handle_dnrs
); it
; it
= iter_next(it
))
1805 dnr
= iter_data(it
);
1807 reply("CSMSG_DNR_INFO_SET", dnr
->chan_name
, intervalString(buf
, now
- dnr
->set
, user
->handle_info
), dnr
->setter
, dnr
->reason
);
1809 reply("CSMSG_DNR_INFO", dnr
->chan_name
, dnr
->setter
, dnr
->reason
);
1812 for(it
= dict_first(plain_dnrs
); it
; it
= iter_next(it
))
1814 dnr
= iter_data(it
);
1816 reply("CSMSG_DNR_INFO_SET", dnr
->chan_name
, intervalString(buf
, now
- dnr
->set
, user
->handle_info
), dnr
->setter
, dnr
->reason
);
1818 reply("CSMSG_DNR_INFO", dnr
->chan_name
, dnr
->setter
, dnr
->reason
);
1821 for(it
= dict_first(mask_dnrs
); it
; it
= iter_next(it
))
1823 dnr
= iter_data(it
);
1825 reply("CSMSG_DNR_INFO_SET", dnr
->chan_name
, intervalString(buf
, now
- dnr
->set
, user
->handle_info
), dnr
->setter
, dnr
->reason
);
1827 reply("CSMSG_DNR_INFO", dnr
->chan_name
, dnr
->setter
, dnr
->reason
);
1832 reply("MSG_MATCH_COUNT", matches
);
1834 reply("MSG_NO_MATCHES");
1840 if(!IsChannelName(target
) && (*target
!= '*'))
1842 reply("CSMSG_NOT_DNR", target
);
1848 const char *reason
= unsplit_string(argv
+ 2, argc
- 2, NULL
);
1849 if((*target
== '*') && !get_handle_info(target
+ 1))
1851 reply("MSG_HANDLE_UNKNOWN", target
+ 1);
1854 chanserv_add_dnr(target
, user
->handle_info
->handle
, reason
);
1855 reply("CSMSG_NOREGISTER_CHANNEL", target
);
1859 reply("CSMSG_DNR_SEARCH_RESULTS");
1862 matches
= chanserv_show_dnrs(user
, cmd
, NULL
, target
+ 1);
1864 matches
= chanserv_show_dnrs(user
, cmd
, target
, NULL
);
1866 reply("MSG_NO_MATCHES");
1870 static CHANSERV_FUNC(cmd_allowregister
)
1872 const char *chan_name
= argv
[1];
1874 if((chan_name
[0] == '*') && dict_find(handle_dnrs
, chan_name
+1, NULL
))
1876 dict_remove(handle_dnrs
, chan_name
+1);
1877 reply("CSMSG_DNR_REMOVED", chan_name
);
1879 else if(dict_find(plain_dnrs
, chan_name
, NULL
))
1881 dict_remove(plain_dnrs
, chan_name
);
1882 reply("CSMSG_DNR_REMOVED", chan_name
);
1884 else if(dict_find(mask_dnrs
, chan_name
, NULL
))
1886 dict_remove(mask_dnrs
, chan_name
);
1887 reply("CSMSG_DNR_REMOVED", chan_name
);
1891 reply("CSMSG_NO_SUCH_DNR", chan_name
);
1898 chanserv_get_owned_count(struct handle_info
*hi
)
1900 struct userData
*cList
;
1903 for(owned
=0, cList
=hi
->channels
; cList
; cList
=cList
->u_next
)
1904 if(cList
->access
== UL_OWNER
)
1909 static CHANSERV_FUNC(cmd_register
)
1911 struct handle_info
*handle
;
1912 struct chanData
*cData
;
1913 struct modeNode
*mn
;
1914 char reason
[MAXLEN
];
1916 unsigned int new_channel
, force
=0;
1917 struct do_not_register
*dnr
;
1923 if(channel
->channel_info
)
1925 reply("CSMSG_ALREADY_REGGED", channel
->name
);
1929 if(channel
->bad_channel
)
1931 reply("CSMSG_ILLEGAL_CHANNEL", channel
->name
);
1935 if(!IsHelping(user
) && (!(mn
= GetUserMode(channel
, user
)) || !(mn
->modes
& MODE_CHANOP
)))
1937 reply("CSMSG_MUST_BE_OPPED", channel
->name
);
1942 chan_name
= channel
->name
;
1948 reply("MSG_MISSING_PARAMS", cmd
->name
);
1949 svccmd_send_help_brief(user
, chanserv
, cmd
);
1952 if(!IsChannelName(argv
[1]))
1954 reply("MSG_NOT_CHANNEL_NAME");
1958 if(opserv_bad_channel(argv
[1]))
1960 reply("CSMSG_ILLEGAL_CHANNEL", argv
[1]);
1965 chan_name
= argv
[1];
1968 if(argc
>= (new_channel
+2))
1970 if(!IsHelping(user
))
1972 reply("CSMSG_PROXY_FORBIDDEN");
1976 if(!(handle
= modcmd_get_handle_info(user
, argv
[new_channel
+1])))
1978 force
= (argc
> (new_channel
+2)) && !irccasecmp(argv
[new_channel
+2], "force");
1979 dnr
= chanserv_is_dnr(chan_name
, handle
);
1981 /* Check if they are over the limit.. */
1982 if((chanserv_get_owned_count(handle
) >= chanserv_conf
.max_owned
) && !force
)
1984 reply("CSMSG_OWN_TOO_MANY", handle
->handle
, chanserv_conf
.max_owned
);
1991 handle
= user
->handle_info
;
1992 dnr
= chanserv_is_dnr(chan_name
, handle
);
1993 /* Check if they are over the limit.. */
1994 if((chanserv_get_owned_count(handle
) >= chanserv_conf
.max_owned
) && !force
)
1996 reply("CSMSG_YOU_OWN_TOO_MANY", chanserv_conf
.max_owned
);
1999 /* Check if another service is in the channel */
2001 for(n
= 0; n
< channel
->members
.used
; n
++)
2003 mn
= channel
->members
.list
[n
];
2004 if((mn
&& mn
->user
&& (mn
->user
->modes
& FLAGS_SERVICE
)) || IsLocal(mn
->user
))
2006 reply("CSMSG_ANOTHER_SERVICE");
2013 if(!IsHelping(user
))
2014 reply("CSMSG_DNR_CHANNEL", chan_name
);
2016 chanserv_show_dnrs(user
, cmd
, chan_name
, handle
->handle
);
2020 /* now handled above for message specilization *
2021 if((chanserv_get_owned_count(handle) >= chanserv_conf.max_owned) && !force)
2023 reply("CSMSG_OWN_TOO_MANY", handle->handle, chanserv_conf.max_owned);
2029 channel
= AddChannel(argv
[1], now
, NULL
, NULL
, NULL
);
2031 cData
= register_channel(channel
, user
->handle_info
->handle
);
2032 scan_user_presence(add_channel_user(cData
, handle
, UL_OWNER
, 0, NULL
), NULL
);
2033 cData
->modes
= chanserv_conf
.default_modes
;
2035 cData
->modes
.modes_set
|= MODE_REGISTERED
;
2036 if (IsOffChannel(cData
))
2038 mod_chanmode_announce(chanserv
, channel
, &cData
->modes
);
2042 struct mod_chanmode
*change
= mod_chanmode_dup(&cData
->modes
, 1);
2043 change
->args
[change
->argc
].mode
= MODE_CHANOP
;
2044 change
->args
[change
->argc
].u
.member
= AddChannelUser(chanserv
, channel
);
2046 mod_chanmode_announce(chanserv
, channel
, change
);
2047 mod_chanmode_free(change
);
2050 /* Initialize the channel's max user record. */
2051 cData
->max
= channel
->members
.used
;
2053 if(handle
!= user
->handle_info
)
2054 reply("CSMSG_PROXY_SUCCESS", handle
->handle
, channel
->name
);
2056 reply("CSMSG_REG_SUCCESS", channel
->name
);
2058 sprintf(reason
, "%s registered to %s by %s.", channel
->name
, handle
->handle
, user
->handle_info
->handle
);
2059 global_message(MESSAGE_RECIPIENT_OPERS
| MESSAGE_RECIPIENT_HELPERS
, reason
);
2064 make_confirmation_string(struct userData
*uData
)
2066 static char strbuf
[16];
2071 for(src
= uData
->handle
->handle
; *src
; )
2072 accum
= accum
* 31 + toupper(*src
++);
2074 for(src
= uData
->channel
->channel
->name
; *src
; )
2075 accum
= accum
* 31 + toupper(*src
++);
2076 sprintf(strbuf
, "%08x", accum
);
2080 static CHANSERV_FUNC(cmd_unregister
)
2083 char reason
[MAXLEN
];
2084 struct chanData
*cData
;
2085 struct userData
*uData
;
2087 cData
= channel
->channel_info
;
2090 reply("CSMSG_NOT_REGISTERED", channel
->name
);
2094 uData
= GetChannelUser(cData
, user
->handle_info
);
2095 if(!uData
|| (uData
->access
< UL_OWNER
))
2097 reply("CSMSG_NO_ACCESS");
2101 if(IsProtected(cData
))
2103 reply("CSMSG_UNREG_NODELETE", channel
->name
);
2107 if(!IsHelping(user
))
2109 const char *confirm_string
;
2110 if(IsSuspended(cData
))
2112 reply("CSMSG_CHAN_SUSPENDED", channel
->name
, cData
->suspended
->reason
);
2115 confirm_string
= make_confirmation_string(uData
);
2116 if((argc
< 2) || strcmp(argv
[1], confirm_string
))
2118 reply("CSMSG_CONFIRM_UNREG", channel
->name
, confirm_string
);
2123 sprintf(reason
, "unregistered by %s.", user
->handle_info
->handle
);
2124 name
= strdup(channel
->name
);
2125 unregister_channel(cData
, reason
);
2126 reply("CSMSG_UNREG_SUCCESS", name
);
2131 static CHANSERV_FUNC(cmd_move
)
2133 struct mod_chanmode change
;
2134 struct chanNode
*target
;
2135 struct modeNode
*mn
;
2136 struct userData
*uData
;
2137 char reason
[MAXLEN
];
2138 struct do_not_register
*dnr
;
2142 if(IsProtected(channel
->channel_info
))
2144 reply("CSMSG_MOVE_NODELETE", channel
->name
);
2148 if(!IsChannelName(argv
[1]))
2150 reply("MSG_NOT_CHANNEL_NAME");
2154 if(opserv_bad_channel(argv
[1]))
2156 reply("CSMSG_ILLEGAL_CHANNEL", argv
[1]);
2160 if(!IsHelping(user
) || (argc
< 3) || irccasecmp(argv
[2], "force"))
2162 for(uData
= channel
->channel_info
->users
; uData
; uData
= uData
->next
)
2164 if((uData
->access
== UL_OWNER
) && (dnr
= chanserv_is_dnr(argv
[1], uData
->handle
)))
2166 if(!IsHelping(user
))
2167 reply("CSMSG_DNR_CHANNEL_MOVE", argv
[1]);
2169 chanserv_show_dnrs(user
, cmd
, argv
[1], uData
->handle
->handle
);
2175 mod_chanmode_init(&change
);
2176 if(!(target
= GetChannel(argv
[1])))
2178 target
= AddChannel(argv
[1], now
, NULL
, NULL
, NULL
);
2179 if(!IsSuspended(channel
->channel_info
))
2180 AddChannelUser(chanserv
, target
);
2182 else if(target
->channel_info
)
2184 reply("CSMSG_ALREADY_REGGED", target
->name
);
2187 else if((!(mn
= GetUserMode(target
, user
)) || !(mn
->modes
&& MODE_CHANOP
))
2188 && !IsHelping(user
))
2190 reply("CSMSG_MUST_BE_OPPED", target
->name
);
2193 else if(!IsSuspended(channel
->channel_info
))
2196 change
.args
[0].mode
= MODE_CHANOP
;
2197 change
.args
[0].u
.member
= AddChannelUser(chanserv
, target
);
2198 mod_chanmode_announce(chanserv
, target
, &change
);
2203 /* Clear MODE_REGISTERED from old channel, add it to new. */
2205 change
.modes_clear
= MODE_REGISTERED
;
2206 mod_chanmode_announce(chanserv
, channel
, &change
);
2207 change
.modes_clear
= 0;
2208 change
.modes_set
= MODE_REGISTERED
;
2209 mod_chanmode_announce(chanserv
, target
, &change
);
2212 /* Move the channel_info to the target channel; it
2213 shouldn't be necessary to clear timeq callbacks
2214 for the old channel. */
2215 target
->channel_info
= channel
->channel_info
;
2216 target
->channel_info
->channel
= target
;
2217 channel
->channel_info
= NULL
;
2219 reply("CSMSG_MOVE_SUCCESS", target
->name
);
2221 sprintf(reason
, "%s moved to %s by %s.", channel
->name
, target
->name
, user
->handle_info
->handle
);
2222 if(!IsSuspended(target
->channel_info
))
2224 char reason2
[MAXLEN
];
2225 sprintf(reason2
, "Channel moved to %s by %s.", target
->name
, user
->handle_info
->handle
);
2226 DelChannelUser(chanserv
, channel
, reason2
, 0);
2228 UnlockChannel(channel
);
2229 LockChannel(target
);
2230 global_message(MESSAGE_RECIPIENT_OPERS
| MESSAGE_RECIPIENT_HELPERS
, reason
);
2235 merge_users(struct chanData
*source
, struct chanData
*target
)
2237 struct userData
*suData
, *tuData
, *next
;
2243 /* Insert the source's users into the scratch area. */
2244 for(suData
= source
->users
; suData
; suData
= suData
->next
)
2245 dict_insert(merge
, suData
->handle
->handle
, suData
);
2247 /* Iterate through the target's users, looking for
2248 users common to both channels. The lower access is
2249 removed from either the scratch area or target user
2251 for(tuData
= target
->users
; tuData
; tuData
= next
)
2253 struct userData
*choice
;
2255 next
= tuData
->next
;
2257 /* If a source user exists with the same handle as a target
2258 channel's user, resolve the conflict by removing one. */
2259 suData
= dict_find(merge
, tuData
->handle
->handle
, NULL
);
2263 /* Pick the data we want to keep. */
2264 /* If the access is the same, use the later seen time. */
2265 if(suData
->access
== tuData
->access
)
2266 choice
= (suData
->seen
> tuData
->seen
) ? suData
: tuData
;
2267 else /* Otherwise, keep the higher access level. */
2268 choice
= (suData
->access
> tuData
->access
) ? suData
: tuData
;
2270 /* Remove the user that wasn't picked. */
2271 if(choice
== tuData
)
2273 dict_remove(merge
, suData
->handle
->handle
);
2274 del_channel_user(suData
, 0);
2277 del_channel_user(tuData
, 0);
2280 /* Move the remaining users to the target channel. */
2281 for(it
= dict_first(merge
); it
; it
= iter_next(it
))
2283 suData
= iter_data(it
);
2285 /* Insert the user into the target channel's linked list. */
2286 suData
->prev
= NULL
;
2287 suData
->next
= target
->users
;
2288 suData
->channel
= target
;
2291 target
->users
->prev
= suData
;
2292 target
->users
= suData
;
2294 /* Update the user counts for the target channel; the
2295 source counts are left alone. */
2296 target
->userCount
++;
2299 /* Possible to assert (source->users == NULL) here. */
2300 source
->users
= NULL
;
2305 merge_bans(struct chanData
*source
, struct chanData
*target
)
2307 struct banData
*sbData
, *tbData
, *sNext
, *tNext
, *tFront
;
2309 /* Hold on to the original head of the target ban list
2310 to avoid comparing source bans with source bans. */
2311 tFront
= target
->bans
;
2313 /* Perform a totally expensive O(n*m) merge, ick. */
2314 for(sbData
= source
->bans
; sbData
; sbData
= sNext
)
2316 /* Flag to track whether the ban's been moved
2317 to the destination yet. */
2320 /* Possible to assert (sbData->prev == NULL) here. */
2321 sNext
= sbData
->next
;
2323 for(tbData
= tFront
; tbData
; tbData
= tNext
)
2325 tNext
= tbData
->next
;
2327 /* Perform two comparisons between each source
2328 and target ban, conflicts are resolved by
2329 keeping the broader ban and copying the later
2330 expiration and triggered time. */
2331 if(match_ircglobs(tbData
->mask
, sbData
->mask
))
2333 /* There is a broader ban in the target channel that
2334 overrides one in the source channel; remove the
2335 source ban and break. */
2336 if(sbData
->expires
> tbData
->expires
)
2337 tbData
->expires
= sbData
->expires
;
2338 if(sbData
->triggered
> tbData
->triggered
)
2339 tbData
->triggered
= sbData
->triggered
;
2340 del_channel_ban(sbData
);
2343 else if(match_ircglobs(sbData
->mask
, tbData
->mask
))
2345 /* There is a broader ban in the source channel that
2346 overrides one in the target channel; remove the
2347 target ban, fall through and move the source over. */
2348 if(tbData
->expires
> sbData
->expires
)
2349 sbData
->expires
= tbData
->expires
;
2350 if(tbData
->triggered
> sbData
->triggered
)
2351 sbData
->triggered
= tbData
->triggered
;
2352 if(tbData
== tFront
)
2354 del_channel_ban(tbData
);
2357 /* Source bans can override multiple target bans, so
2358 we allow a source to run through this loop multiple
2359 times, but we can only move it once. */
2364 /* Remove the source ban from the source ban list. */
2366 sbData
->next
->prev
= sbData
->prev
;
2368 /* Modify the source ban's associated channel. */
2369 sbData
->channel
= target
;
2371 /* Insert the ban into the target channel's linked list. */
2372 sbData
->prev
= NULL
;
2373 sbData
->next
= target
->bans
;
2376 target
->bans
->prev
= sbData
;
2377 target
->bans
= sbData
;
2379 /* Update the user counts for the target channel. */
2384 /* Possible to assert (source->bans == NULL) here. */
2385 source
->bans
= NULL
;
2389 merge_data(struct chanData
*source
, struct chanData
*target
)
2391 if(source
->visited
> target
->visited
)
2392 target
->visited
= source
->visited
;
2396 merge_channel(struct chanData
*source
, struct chanData
*target
)
2398 merge_users(source
, target
);
2399 merge_bans(source
, target
);
2400 merge_data(source
, target
);
2403 static CHANSERV_FUNC(cmd_merge
)
2405 struct userData
*target_user
;
2406 struct chanNode
*target
;
2407 char reason
[MAXLEN
];
2411 /* Make sure the target channel exists and is registered to the user
2412 performing the command. */
2413 if(!(target
= GetChannel(argv
[1])))
2415 reply("MSG_INVALID_CHANNEL");
2419 if(!target
->channel_info
)
2421 reply("CSMSG_NOT_REGISTERED", target
->name
);
2425 if(IsProtected(channel
->channel_info
))
2427 reply("CSMSG_MERGE_NODELETE");
2431 if(IsSuspended(target
->channel_info
))
2433 reply("CSMSG_MERGE_SUSPENDED");
2437 if(channel
== target
)
2439 reply("CSMSG_MERGE_SELF");
2443 target_user
= GetChannelUser(target
->channel_info
, user
->handle_info
);
2444 if(!target_user
|| (target_user
->access
< UL_OWNER
))
2446 reply("CSMSG_MERGE_NOT_OWNER");
2450 /* Merge the channel structures and associated data. */
2451 merge_channel(channel
->channel_info
, target
->channel_info
);
2452 sprintf(reason
, "merged into %s by %s.", target
->name
, user
->handle_info
->handle
);
2453 unregister_channel(channel
->channel_info
, reason
);
2454 reply("CSMSG_MERGE_SUCCESS", target
->name
);
2458 static CHANSERV_FUNC(cmd_opchan
)
2460 struct mod_chanmode change
;
2461 if(!IsHelping(user
) && !channel
->channel_info
->may_opchan
)
2463 reply("CSMSG_ALREADY_OPCHANNED", channel
->name
);
2466 channel
->channel_info
->may_opchan
= 0;
2467 mod_chanmode_init(&change
);
2469 change
.args
[0].mode
= MODE_CHANOP
;
2470 change
.args
[0].u
.member
= GetUserMode(channel
, chanserv
);
2471 mod_chanmode_announce(chanserv
, channel
, &change
);
2472 reply("CSMSG_OPCHAN_DONE", channel
->name
);
2476 static CHANSERV_FUNC(cmd_adduser
)
2478 struct userData
*actee
;
2479 struct userData
*actor
;
2480 struct handle_info
*handle
;
2481 unsigned short access
;
2485 if(channel
->channel_info
->userCount
>= chanserv_conf
.max_chan_users
)
2487 reply("CSMSG_MAXIMUM_USERS", chanserv_conf
.max_chan_users
);
2491 access
= user_level_from_name(argv
[2], UL_OWNER
);
2494 reply("CSMSG_INVALID_ACCESS", argv
[2]);
2498 actor
= GetChannelUser(channel
->channel_info
, user
->handle_info
);
2499 if(actor
->access
<= access
)
2501 reply("CSMSG_NO_BUMP_ACCESS");
2505 if(!(handle
= modcmd_get_handle_info(user
, argv
[1])))
2507 // 'kevin must first authenticate with AuthServ.' is sent to user
2508 struct userNode
*unode
;
2509 unode
= GetUserH(argv
[1]); /* find user struct by nick */
2512 if(find_adduser_pending(channel
, unode
)) {
2513 reply("CSMSG_ADDUSER_PENDING_ALREADY", channel
->name
);
2516 if(IsInChannel(channel
, unode
)) {
2517 reply("CSMSG_ADDUSER_PENDING");
2518 add_adduser_pending(channel
, unode
, access
);
2519 send_message_type(1,unode
, chanserv
, "CSMSG_ADDUSER_PENDING_TARGET", user
->nick
, channel
->name
);
2521 /* this results in user must auth AND not in chan errors. too confusing..
2523 reply("CSMSG_ADDUSER_PENDING_NOTINCHAN", channel->name);
2531 if((actee
= GetTrueChannelAccess(channel
->channel_info
, handle
)))
2533 reply("CSMSG_USER_EXISTS", handle
->handle
, channel
->name
, user_level_name_from_level(actee
->access
));
2537 actee
= add_channel_user(channel
->channel_info
, handle
, access
, 0, NULL
);
2538 scan_user_presence(actee
, NULL
);
2539 reply("CSMSG_ADDED_USER", handle
->handle
, channel
->name
, user_level_name_from_level(access
), access
);
2543 static CHANSERV_FUNC(cmd_clvl
)
2545 struct handle_info
*handle
;
2546 struct userData
*victim
;
2547 struct userData
*actor
;
2548 unsigned short new_access
;
2549 int privileged
= IsHelping(user
) && ((user
->handle_info
->opserv_level
>= chanserv_conf
.nodelete_level
) || !IsProtected(channel
->channel_info
));
2553 actor
= GetChannelUser(channel
->channel_info
, user
->handle_info
);
2555 if(!(handle
= modcmd_get_handle_info(user
, argv
[1])))
2558 if(handle
== user
->handle_info
&& !privileged
)
2560 reply("CSMSG_NO_SELF_CLVL");
2564 if(!(victim
= GetTrueChannelAccess(channel
->channel_info
, handle
)))
2566 reply("CSMSG_NO_CHAN_USER", handle
->handle
, channel
->name
);
2570 if(actor
->access
<= victim
->access
&& !privileged
)
2572 reply("MSG_USER_OUTRANKED", handle
->handle
);
2576 new_access
= user_level_from_name(argv
[2], UL_OWNER
);
2580 reply("CSMSG_INVALID_ACCESS", argv
[2]);
2584 if(new_access
>= actor
->access
&& !privileged
)
2586 reply("CSMSG_NO_BUMP_ACCESS");
2590 victim
->access
= new_access
;
2591 reply("CSMSG_CHANGED_ACCESS", handle
->handle
, user_level_name_from_level(new_access
), new_access
, channel
->name
);
2595 static CHANSERV_FUNC(cmd_deluser
)
2597 struct handle_info
*handle
;
2598 struct userData
*victim
;
2599 struct userData
*actor
;
2600 unsigned short access
;
2605 actor
= GetChannelUser(channel
->channel_info
, user
->handle_info
);
2607 if(!(handle
= modcmd_get_handle_info(user
, argv
[argc
-1])))
2610 if(!(victim
= GetTrueChannelAccess(channel
->channel_info
, handle
)))
2612 reply("CSMSG_NO_CHAN_USER", handle
->handle
, channel
->name
);
2618 access
= user_level_from_name(argv
[1], UL_OWNER
);
2621 reply("CSMSG_INVALID_ACCESS", argv
[1]);
2624 if(access
!= victim
->access
)
2626 reply("CSMSG_INCORRECT_ACCESS", handle
->handle
, user_level_name_from_level(victim
->access
), argv
[1]);
2632 access
= victim
->access
;
2635 if((actor
->access
<= victim
->access
) && !IsHelping(user
))
2637 reply("MSG_USER_OUTRANKED", victim
->handle
->handle
);
2641 chan_name
= strdup(channel
->name
);
2642 del_channel_user(victim
, 1);
2643 reply("CSMSG_DELETED_USER", handle
->handle
, access
, chan_name
);
2649 cmd_mdel_user(struct userNode
*user
, struct chanNode
*channel
, unsigned short min_access
, unsigned short max_access
, char *mask
, struct svccmd
*cmd
)
2651 struct userData
*actor
, *uData
, *next
;
2653 actor
= GetChannelUser(channel
->channel_info
, user
->handle_info
);
2655 if(min_access
> max_access
)
2657 reply("CSMSG_BAD_RANGE", min_access
, max_access
);
2661 if((actor
->access
<= max_access
) && !IsHelping(user
))
2663 reply("CSMSG_NO_ACCESS");
2667 for(uData
= channel
->channel_info
->users
; uData
; uData
= next
)
2671 if((uData
->access
>= min_access
)
2672 && (uData
->access
<= max_access
)
2673 && match_ircglob(uData
->handle
->handle
, mask
))
2674 del_channel_user(uData
, 1);
2677 reply("CSMSG_DELETED_USERS", mask
, min_access
, max_access
, channel
->name
);
2681 static CHANSERV_FUNC(cmd_mdelowner
)
2683 return cmd_mdel_user(user
, channel
, UL_OWNER
, UL_OWNER
, argv
[1], cmd
);
2686 static CHANSERV_FUNC(cmd_mdelcoowner
)
2688 return cmd_mdel_user(user
, channel
, UL_COOWNER
, UL_COOWNER
, argv
[1], cmd
);
2691 static CHANSERV_FUNC(cmd_mdelmanager
)
2693 return cmd_mdel_user(user
, channel
, UL_MANAGER
, UL_MANAGER
, argv
[1], cmd
);
2696 static CHANSERV_FUNC(cmd_mdelop
)
2698 return cmd_mdel_user(user
, channel
, UL_OP
, UL_OP
, argv
[1], cmd
);
2701 static CHANSERV_FUNC(cmd_mdelpeon
)
2703 return cmd_mdel_user(user
, channel
, UL_PEON
, UL_PEON
, argv
[1], cmd
);
2706 static CHANSERV_FUNC(cmd_mdelhalfop
)
2708 return cmd_mdel_user(user
, channel
, UL_HALFOP
, UL_HALFOP
, argv
[1], cmd
);
2714 cmd_trim_bans(struct userNode
*user
, struct chanNode
*channel
, unsigned long duration
)
2716 struct banData
*bData
, *next
;
2717 char interval
[INTERVALLEN
];
2722 limit
= now
- duration
;
2723 for(bData
= channel
->channel_info
->bans
; bData
; bData
= next
)
2727 if((bData
->triggered
&& bData
->triggered
>= limit
) || (bData
->set
&& bData
->set
>= limit
))
2730 del_channel_ban(bData
);
2734 intervalString(interval
, duration
, user
->handle_info
);
2735 send_message(user
, chanserv
, "CSMSG_TRIMMED_LAMERS", count
, channel
->name
, interval
);
2740 cmd_trim_users(struct userNode
*user
, struct chanNode
*channel
, unsigned short min_access
, unsigned short max_access
, unsigned long duration
)
2742 struct userData
*actor
, *uData
, *next
;
2743 char interval
[INTERVALLEN
];
2747 actor
= GetChannelUser(channel
->channel_info
, user
->handle_info
);
2748 if(min_access
> max_access
)
2750 send_message(user
, chanserv
, "CSMSG_BAD_RANGE", min_access
, max_access
);
2754 if((actor
->access
<= max_access
) && !IsHelping(user
))
2756 send_message(user
, chanserv
, "CSMSG_NO_ACCESS");
2761 limit
= now
- duration
;
2762 for(uData
= channel
->channel_info
->users
; uData
; uData
= next
)
2766 if((uData
->seen
> limit
) || uData
->present
)
2769 if(((uData
->access
>= min_access
) && (uData
->access
<= max_access
))
2770 || (!max_access
&& (uData
->access
< actor
->access
)))
2772 del_channel_user(uData
, 1);
2780 max_access
= (actor
->access
> UL_OWNER
) ? UL_OWNER
: (actor
->access
- 1);
2782 send_message(user
, chanserv
, "CSMSG_TRIMMED_USERS", count
, min_access
, max_access
, channel
->name
, intervalString(interval
, duration
, user
->handle_info
));
2786 static CHANSERV_FUNC(cmd_trim
)
2788 unsigned long duration
;
2789 unsigned short min_level
, max_level
;
2793 duration
= ParseInterval(argv
[2]);
2796 reply("CSMSG_CANNOT_TRIM");
2800 if(!irccasecmp(argv
[1], "lamers"))
2802 cmd_trim_bans(user
, channel
, duration
); /* trim_lamers.. */
2805 else if(!irccasecmp(argv
[1], "users"))
2807 cmd_trim_users(user
, channel
, 0, 0, duration
);
2810 else if(parse_level_range(&min_level
, &max_level
, argv
[1]))
2812 cmd_trim_users(user
, channel
, min_level
, max_level
, duration
);
2815 else if((min_level
= user_level_from_name(argv
[1], UL_OWNER
)))
2817 cmd_trim_users(user
, channel
, min_level
, min_level
, duration
);
2822 reply("CSMSG_INVALID_TRIM", argv
[1]);
2827 /* If argc is 0 in cmd_up or cmd_down, no notices will be sent
2828 to the user. cmd_all takes advantage of this. */
2829 static CHANSERV_FUNC(cmd_up
)
2831 struct mod_chanmode change
;
2832 struct userData
*uData
;
2835 mod_chanmode_init(&change
);
2837 change
.args
[0].u
.member
= GetUserMode(channel
, user
);
2838 if(!change
.args
[0].u
.member
)
2841 reply("MSG_CHANNEL_ABSENT", channel
->name
);
2845 uData
= GetChannelAccess(channel
->channel_info
, user
->handle_info
);
2849 reply("CSMSG_GODMODE_UP", argv
[0]);
2852 else if(uData
->access
>= UL_OP
)
2854 change
.args
[0].mode
= MODE_CHANOP
;
2855 errmsg
= "CSMSG_ALREADY_OPPED";
2857 else if(uData
->access
>= UL_HALFOP
)
2859 change
.args
[0].mode
= MODE_HALFOP
;
2860 errmsg
= "CSMSG_ALREADY_HALFOPPED";
2862 else if(uData
->access
>= UL_PEON
&& (channel
->channel_info
->chOpts
[chAutomode
] != 'm' ))
2864 change
.args
[0].mode
= MODE_VOICE
;
2865 errmsg
= "CSMSG_ALREADY_VOICED";
2870 reply("CSMSG_NO_ACCESS");
2873 change
.args
[0].mode
&= ~change
.args
[0].u
.member
->modes
;
2874 if(!change
.args
[0].mode
)
2877 reply(errmsg
, channel
->name
);
2880 modcmd_chanmode_announce(&change
);
2884 static CHANSERV_FUNC(cmd_down
)
2886 struct mod_chanmode change
;
2888 mod_chanmode_init(&change
);
2890 change
.args
[0].u
.member
= GetUserMode(channel
, user
);
2891 if(!change
.args
[0].u
.member
)
2894 reply("MSG_CHANNEL_ABSENT", channel
->name
);
2898 if(!change
.args
[0].u
.member
->modes
)
2901 reply("CSMSG_ALREADY_DOWN", channel
->name
);
2905 change
.args
[0].mode
= MODE_REMOVE
| change
.args
[0].u
.member
->modes
;
2906 modcmd_chanmode_announce(&change
);
2910 static int cmd_all(struct userNode
*user
, UNUSED_ARG(struct chanNode
*channel
), UNUSED_ARG(unsigned int argc
), UNUSED_ARG(char *argv
[]), struct svccmd
*cmd
, modcmd_func_t mcmd
)
2912 struct userData
*cList
;
2914 for(cList
= user
->handle_info
->channels
; cList
; cList
= cList
->u_next
)
2916 if(IsSuspended(cList
->channel
)
2917 || IsUserSuspended(cList
)
2918 || !GetUserMode(cList
->channel
->channel
, user
))
2921 mcmd(user
, cList
->channel
->channel
, 0, NULL
, cmd
);
2927 static CHANSERV_FUNC(cmd_upall
)
2929 return cmd_all(CSFUNC_ARGS
, cmd_up
);
2932 static CHANSERV_FUNC(cmd_downall
)
2934 return cmd_all(CSFUNC_ARGS
, cmd_down
);
2937 typedef int validate_func_t(struct userNode
*user
, struct chanNode
*channel
, struct userNode
*victim
);
2938 typedef void process_func_t(unsigned int num
, struct userNode
**newops
, struct chanNode
*channel
, struct userNode
*who
, int announce
);
2941 modify_users(struct userNode
*user
, struct chanNode
*channel
, unsigned int argc
, char *argv
[], struct svccmd
*cmd
, validate_func_t validate
, chan_mode_t mode
, char *action
)
2943 unsigned int ii
, valid
;
2944 struct userNode
*victim
;
2945 struct mod_chanmode
*change
;
2947 change
= mod_chanmode_alloc(argc
- 1);
2949 for(ii
=valid
=0; ++ii
< argc
; )
2951 if(!(victim
= GetUserH(argv
[ii
])))
2953 change
->args
[valid
].mode
= mode
;
2954 change
->args
[valid
].u
.member
= GetUserMode(channel
, victim
);
2955 if(!change
->args
[valid
].u
.member
)
2957 if(validate
&& !validate(user
, channel
, victim
))
2962 change
->argc
= valid
;
2963 if(valid
< (argc
-1))
2964 reply("CSMSG_PROCESS_FAILED");
2967 modcmd_chanmode_announce(change
);
2968 reply(action
, channel
->name
);
2970 mod_chanmode_free(change
);
2974 static CHANSERV_FUNC(cmd_op
)
2976 return modify_users(CSFUNC_ARGS
, validate_op
, MODE_CHANOP
, "CSMSG_OPPED_USERS");
2979 static CHANSERV_FUNC(cmd_hop
)
2981 return modify_users(CSFUNC_ARGS
, validate_halfop
, MODE_HALFOP
, "CSMSG_HALFOPPED_USERS");
2984 static CHANSERV_FUNC(cmd_deop
)
2986 return modify_users(CSFUNC_ARGS
, validate_deop
, MODE_REMOVE
|MODE_CHANOP
, "CSMSG_DEOPPED_USERS");
2989 static CHANSERV_FUNC(cmd_dehop
)
2991 return modify_users(CSFUNC_ARGS
, validate_dehop
, MODE_REMOVE
|MODE_HALFOP
, "CSMSG_DEHALFOPPED_USERS");
2994 static CHANSERV_FUNC(cmd_voice
)
2996 return modify_users(CSFUNC_ARGS
, NULL
, MODE_VOICE
, "CSMSG_VOICED_USERS");
2999 static CHANSERV_FUNC(cmd_devoice
)
3001 return modify_users(CSFUNC_ARGS
, NULL
, MODE_REMOVE
|MODE_VOICE
, "CSMSG_DEVOICED_USERS");
3005 bad_channel_ban(struct chanNode
*channel
, struct userNode
*user
, const char *ban
, int *victimCount
, struct modeNode
**victims
)
3011 for(ii
=0; ii
<channel
->members
.used
; ii
++)
3013 struct modeNode
*mn
= channel
->members
.list
[ii
];
3015 if(IsService(mn
->user
))
3018 if(!user_matches_glob(mn
->user
, ban
, 1))
3021 if(protect_user(mn
->user
, user
, channel
->channel_info
))
3025 victims
[(*victimCount
)++] = mn
;
3031 eject_user(struct userNode
*user
, struct chanNode
*channel
, unsigned int argc
, char *argv
[], struct svccmd
*cmd
, int action
)
3033 struct userNode
*victim
;
3034 struct modeNode
**victims
;
3035 unsigned int offset
, n
, victimCount
, duration
= 0;
3036 char *reason
= "Bye.", *ban
, *name
;
3037 char interval
[INTERVALLEN
];
3039 offset
= (action
& ACTION_ADD_TIMED_LAMER
) ? 3 : 2;
3040 REQUIRE_PARAMS(offset
);
3043 reason
= unsplit_string(argv
+ offset
, argc
- offset
, NULL
);
3044 if(strlen(reason
) > (TOPICLEN
- (NICKLEN
+ 3)))
3046 /* Truncate the reason to a length of TOPICLEN, as
3047 the ircd does; however, leave room for an ellipsis
3048 and the kicker's nick. */
3049 sprintf(reason
+ (TOPICLEN
- (NICKLEN
+ 6)), "...");
3053 if((victim
= GetUserH(argv
[1])))
3055 victims
= alloca(sizeof(victims
[0]));
3056 victims
[0] = GetUserMode(channel
, victim
);
3057 /* XXX: The comparison with ACTION_KICK is just because all
3058 * other actions can work on users outside the channel, and we
3059 * want to allow those (e.g. unbans) in that case. If we add
3060 * some other ejection action for in-channel users, change
3062 victimCount
= victims
[0] ? 1 : 0;
3064 if(IsService(victim
))
3067 reply("MSG_SERVICE_IMMUNE", victim
->nick
);
3071 if((action
== ACTION_KICK
) && !victimCount
)
3074 reply("MSG_CHANNEL_USER_ABSENT", victim
->nick
, channel
->name
);
3078 if(protect_user(victim
, user
, channel
->channel_info
))
3080 // This translates to send_message(user, cmd->parent->bot, ...)
3081 // if user is x3 (ctcp action) cmd is null and segfault.
3083 reply("CSMSG_USER_PROTECTED", victim
->nick
);
3087 ban
= generate_hostmask(victim
, GENMASK_STRICT_HOST
|GENMASK_ANY_IDENT
);
3088 name
= victim
->nick
;
3092 if(!is_ircmask(argv
[1]))
3095 reply("MSG_NICK_UNKNOWN", argv
[1]);
3099 victims
= alloca(sizeof(victims
[0]) * channel
->members
.used
);
3101 if(bad_channel_ban(channel
, user
, argv
[1], &victimCount
, victims
))
3104 reply("CSMSG_MASK_PROTECTED", argv
[1]);
3107 /* We dont actually want a victem count if were banning a mask manually, IMO -Rubin*/
3109 victimCount
= 0; /* Dont deop etc ppl who match this */
3111 #ifdef entropy_lameness
3112 if((victimCount
> 4) && ((victimCount
* 3) > channel
->members
.used
) && !IsOper(user
))
3115 reply("CSMSG_LAME_MASK", argv
[1]);
3120 if((action
== ACTION_KICK
) && (victimCount
== 0))
3123 reply("CSMSG_NO_MATCHING_USERS", channel
->name
, argv
[1]);
3127 name
= ban
= strdup(argv
[1]);
3130 /* Truncate the ban in place if necessary; we must ensure
3131 that 'ban' is a valid ban mask before sanitizing it. */
3132 sanitize_ircmask(ban
);
3134 if(action
& ACTION_ADD_LAMER
)
3136 struct banData
*bData
, *next
;
3138 if(channel
->channel_info
->banCount
>= chanserv_conf
.max_chan_bans
) /* ..lamers.. */
3141 reply("CSMSG_MAXIMUM_LAMERS", chanserv_conf
.max_chan_bans
); /* ..lamers.. */
3146 if(action
& ACTION_ADD_TIMED_LAMER
)
3148 duration
= ParseInterval(argv
[2]);
3153 reply("CSMSG_DURATION_TOO_LOW");
3157 else if(duration
> (86400 * 365 * 2))
3160 reply("CSMSG_DURATION_TOO_HIGH");
3167 for(bData
= channel
->channel_info
->bans
; bData
; bData
= next
)
3169 if(match_ircglobs(bData
->mask
, ban
))
3171 int exact
= !irccasecmp(bData
->mask
, ban
);
3173 /* The ban is redundant; there is already a ban
3174 with the same effect in place. */
3178 free(bData
->reason
);
3179 bData
->reason
= strdup(reason
);
3180 safestrncpy(bData
->owner
, (user
->handle_info
? user
->handle_info
->handle
: user
->nick
), sizeof(bData
->owner
));
3182 reply("CSMSG_REASON_CHANGE", ban
);
3186 if(exact
&& bData
->expires
)
3190 /* If the ban matches an existing one exactly,
3191 extend the expiration time if the provided
3192 duration is longer. */
3193 if(duration
&& ((time_t)(now
+ duration
) > bData
->expires
))
3195 bData
->expires
= now
+ duration
;
3206 /* Delete the expiration timeq entry and
3207 requeue if necessary. */
3208 timeq_del(0, expire_ban
, bData
, TIMEQ_IGNORE_WHEN
);
3211 timeq_add(bData
->expires
, expire_ban
, bData
);
3215 /* automated kickban, dont reply */
3218 reply("CSMSG_LAMER_EXTENDED", ban
, intervalString(interval
, duration
, user
->handle_info
));
3220 reply("CSMSG_LAMER_ADDED", name
, channel
->name
);
3226 reply("CSMSG_REDUNDANT_LAMER", name
, channel
->name
);
3233 if(match_ircglobs(ban
, bData
->mask
))
3235 /* The ban we are adding makes previously existing
3236 bans redundant; silently remove them. */
3237 del_channel_ban(bData
);
3241 bData
= add_channel_ban(channel
->channel_info
, ban
, (user
->handle_info
? user
->handle_info
->handle
: user
->nick
), now
, (victimCount
? now
: 0), (duration
? now
+ duration
: 0), reason
);
3243 name
= ban
= strdup(bData
->mask
);
3247 /* WHAT DOES THIS DO?? -Rubin */
3248 for(n
= 0; n
< chanserv_conf
.old_ban_names
->used
; ++n
)
3250 extern const char *hidden_host_suffix
;
3251 const char *old_name
= chanserv_conf
.old_ban_names
->list
[n
];
3253 unsigned int l1
, l2
;
3256 l2
= strlen(old_name
);
3259 if(irccasecmp(ban
+ l1
- l2
, old_name
))
3261 new_mask
= malloc(MAXLEN
);
3262 sprintf(new_mask
, "%.*s%s", (int)(l1
-l2
), ban
, hidden_host_suffix
);
3264 name
= ban
= new_mask
;
3269 if(action
& ACTION_BAN
)
3271 unsigned int exists
;
3272 struct mod_chanmode
*change
;
3274 if(channel
->banlist
.used
>= MAXBANS
)
3277 reply("CSMSG_BANLIST_FULL", channel
->name
);
3282 exists
= ChannelBanExists(channel
, ban
);
3283 change
= mod_chanmode_alloc(victimCount
+ 1);
3284 for(n
= 0; n
< victimCount
; ++n
)
3286 change
->args
[n
].mode
= MODE_REMOVE
|MODE_CHANOP
|MODE_HALFOP
|MODE_VOICE
;
3287 change
->args
[n
].u
.member
= victims
[n
];
3291 change
->args
[n
].mode
= MODE_BAN
;
3292 change
->args
[n
++].u
.hostmask
= ban
;
3296 modcmd_chanmode_announce(change
);
3298 mod_chanmode_announce(chanserv
, channel
, change
);
3299 mod_chanmode_free(change
);
3301 if(exists
&& (action
== ACTION_BAN
))
3304 reply("CSMSG_REDUNDANT_BAN", name
, channel
->name
);
3310 if(action
& ACTION_KICK
)
3312 char kick_reason
[MAXLEN
];
3313 sprintf(kick_reason
, "(%s) %s", user
->nick
, reason
);
3315 for(n
= 0; n
< victimCount
; n
++)
3316 KickChannelUser(victims
[n
]->user
, channel
, chanserv
, kick_reason
);
3321 /* No response, since it was automated. */
3323 else if(action
& ACTION_ADD_LAMER
)
3326 reply("CSMSG_TIMED_LAMER_ADDED", name
, channel
->name
, intervalString(interval
, duration
, user
->handle_info
));
3328 reply("CSMSG_LAMER_ADDED", name
, channel
->name
);
3330 else if((action
& (ACTION_BAN
| ACTION_KICK
)) == (ACTION_BAN
| ACTION_KICK
))
3331 reply("CSMSG_KICK_BAN_DONE", name
, channel
->name
);
3332 else if(action
& ACTION_BAN
)
3333 reply("CSMSG_BAN_DONE", name
, channel
->name
);
3334 else if(action
& ACTION_KICK
&& victimCount
)
3335 reply("CSMSG_KICK_DONE", name
, channel
->name
);
3341 static CHANSERV_FUNC(cmd_kickban
)
3343 return eject_user(CSFUNC_ARGS
, ACTION_KICK
| ACTION_BAN
);
3346 static CHANSERV_FUNC(cmd_kick
)
3348 return eject_user(CSFUNC_ARGS
, ACTION_KICK
);
3351 static CHANSERV_FUNC(cmd_ban
)
3353 return eject_user(CSFUNC_ARGS
, ACTION_BAN
);
3356 static CHANSERV_FUNC(cmd_addlamer
)
3358 return eject_user(CSFUNC_ARGS
, ACTION_KICK
| ACTION_BAN
| ACTION_ADD_LAMER
);
3361 static CHANSERV_FUNC(cmd_addtimedlamer
)
3363 return eject_user(CSFUNC_ARGS
, ACTION_KICK
| ACTION_BAN
| ACTION_ADD_LAMER
| ACTION_ADD_TIMED_LAMER
);
3366 static struct mod_chanmode
*
3367 find_matching_bans(struct banList
*bans
, struct userNode
*actee
, const char *mask
)
3369 struct mod_chanmode
*change
;
3370 unsigned char *match
;
3371 unsigned int ii
, count
;
3373 match
= alloca(bans
->used
);
3376 for(ii
= count
= 0; ii
< bans
->used
; ++ii
)
3378 match
[ii
] = user_matches_glob(actee
, bans
->list
[ii
]->ban
, 1);
3385 for(ii
= count
= 0; ii
< bans
->used
; ++ii
)
3387 match
[ii
] = match_ircglobs(mask
, bans
->list
[ii
]->ban
);
3394 change
= mod_chanmode_alloc(count
);
3395 for(ii
= count
= 0; ii
< bans
->used
; ++ii
)
3399 change
->args
[count
].mode
= MODE_REMOVE
| MODE_BAN
;
3400 change
->args
[count
++].u
.hostmask
= strdup(bans
->list
[ii
]->ban
);
3402 assert(count
== change
->argc
);
3406 void expire_bans(UNUSED_ARG(void* data
)) /* Real bans, not lamers */
3408 unsigned int jj
, ii
, count
;
3410 struct chanData
*channel
;
3412 struct mod_chanmode
*change
;
3414 log_module(CS_LOG
, LOG_DEBUG
, "Checking for expired bans");
3415 /* Walk through every channel */
3416 for(channel
= channelList
; channel
; channel
= channel
->next
) {
3417 switch(channel
->chOpts
[chBanTimeout
])
3419 default: case '0': continue; /* Dont remove bans in this chan */
3420 case '1': bantimeout
= now
- (10 * 60); break; /* 10 minutes */
3421 case '2': bantimeout
= now
- (2 * 60 * 60); break; /* 2 hours */
3422 case '3': bantimeout
= now
- (4 * 60 * 60); break; /* 4 hours */
3423 case '4': bantimeout
= now
- (24 * 60 * 60); break; /* 24 hours */
3424 case '5': bantimeout
= now
- (7 * 24 * 60 * 60); break; /* 1 week */
3427 /* First find out how many bans were going to unset */
3428 for (jj
=0; jj
< channel
->channel
->banlist
.used
; ++jj
) {
3429 if(channel
->channel
->banlist
.list
[jj
]->set
< bantimeout
)
3433 /* At least one ban, so setup a removal */
3434 change
= mod_chanmode_alloc(count
);
3436 /* Walk over every ban in this channel.. */
3437 for (jj
=0; jj
< channel
->channel
->banlist
.used
; ++jj
) {
3438 bn
= channel
->channel
->banlist
.list
[jj
];
3439 if (bn
->set
< bantimeout
) {
3440 log_module(CS_LOG
, LOG_DEBUG
, "Removing ban %s from %s", bn
->ban
, channel
->channel
->name
);
3442 /* Add this ban to the mode change */
3443 change
->args
[ii
].mode
= MODE_REMOVE
| MODE_BAN
;
3444 change
->args
[ii
].u
.hostmask
= strdup(bn
->ban
);
3446 /* Pull this ban out of the list */
3447 banList_remove(&(channel
->channel
->banlist
), bn
);
3452 /* Send the modes to IRC */
3453 mod_chanmode_announce(chanserv
, channel
->channel
, change
);
3455 /* free memory from strdup above */
3456 for(ii
= 0; ii
< count
; ++ii
)
3457 free((char*)change
->args
[ii
].u
.hostmask
);
3459 mod_chanmode_free(change
);
3462 /* Set this function to run again */
3463 if(chanserv_conf
.ban_timeout_frequency
)
3464 timeq_add(now
+ chanserv_conf
.ban_timeout_frequency
, expire_bans
, NULL
);
3469 unban_user(struct userNode
*user
, struct chanNode
*channel
, unsigned int argc
, char *argv
[], struct svccmd
*cmd
, int action
)
3471 struct userNode
*actee
;
3477 /* may want to allow a comma delimited list of users... */
3478 if(!(actee
= GetUserH(argv
[1])))
3480 if(!is_ircmask(argv
[1]))
3482 reply("MSG_NICK_UNKNOWN", argv
[1]);
3486 mask
= strdup(argv
[1]);
3489 /* We don't sanitize the mask here because ircu
3491 if(action
& ACTION_UNBAN
)
3493 struct mod_chanmode
*change
;
3494 change
= find_matching_bans(&channel
->banlist
, actee
, mask
);
3499 modcmd_chanmode_announce(change
);
3500 for(ii
= 0; ii
< change
->argc
; ++ii
)
3501 free((char*)change
->args
[ii
].u
.hostmask
);
3502 mod_chanmode_free(change
);
3507 if(action
& ACTION_DEL_LAMER
)
3509 struct banData
*ban
, *next
;
3511 ban
= channel
->channel_info
->bans
; /* lamers */
3515 for( ; ban
&& !user_matches_glob(actee
, ban
->mask
, 1);
3518 for( ; ban
&& !match_ircglobs(mask
, ban
->mask
);
3523 del_channel_ban(ban
);
3530 reply("CSMSG_BAN_NOT_FOUND", actee
? actee
->nick
: mask
);
3532 reply("CSMSG_BAN_REMOVED", actee
? actee
->nick
: mask
);
3538 static CHANSERV_FUNC(cmd_unban
)
3540 return unban_user(CSFUNC_ARGS
, ACTION_UNBAN
);
3543 static CHANSERV_FUNC(cmd_dellamer
)
3545 /* it doesn't necessarily have to remove the channel ban - may want
3546 to make that an option. */
3547 return unban_user(CSFUNC_ARGS
, ACTION_UNBAN
| ACTION_DEL_LAMER
);
3550 static CHANSERV_FUNC(cmd_unbanme
)
3552 struct userData
*uData
= GetChannelUser(channel
->channel_info
, user
->handle_info
);
3553 long flags
= ACTION_UNBAN
;
3555 /* remove permanent bans if the user has the proper access. */
3556 if(uData
->access
>= UL_MANAGER
)
3557 flags
|= ACTION_DEL_LAMER
;
3559 argv
[1] = user
->nick
;
3560 return unban_user(user
, channel
, 2, argv
, cmd
, flags
);
3563 static CHANSERV_FUNC(cmd_unbanall
)
3565 struct mod_chanmode
*change
;
3568 if(!channel
->banlist
.used
)
3570 reply("CSMSG_NO_BANS", channel
->name
);
3574 change
= mod_chanmode_alloc(channel
->banlist
.used
);
3575 for(ii
=0; ii
<channel
->banlist
.used
; ii
++)
3577 change
->args
[ii
].mode
= MODE_REMOVE
| MODE_BAN
;
3578 change
->args
[ii
].u
.hostmask
= strdup(channel
->banlist
.list
[ii
]->ban
);
3580 modcmd_chanmode_announce(change
);
3581 for(ii
= 0; ii
< change
->argc
; ++ii
)
3582 free((char*)change
->args
[ii
].u
.hostmask
);
3583 mod_chanmode_free(change
);
3584 reply("CSMSG_BANS_REMOVED", channel
->name
);
3588 static CHANSERV_FUNC(cmd_open
)
3590 struct mod_chanmode
*change
;
3593 change
= find_matching_bans(&channel
->banlist
, user
, NULL
);
3595 change
= mod_chanmode_alloc(0);
3596 change
->modes_clear
|= MODE_INVITEONLY
| MODE_LIMIT
| MODE_KEY
;
3597 if(!check_user_level(channel
, user
, lvlEnfModes
, 1, 0)
3598 && channel
->channel_info
->modes
.modes_set
)
3599 change
->modes_clear
&= ~channel
->channel_info
->modes
.modes_set
;
3600 modcmd_chanmode_announce(change
);
3601 reply("CSMSG_CHANNEL_OPENED", channel
->name
);
3602 for(ii
= 0; ii
< change
->argc
; ++ii
)
3603 free((char*)change
->args
[ii
].u
.hostmask
);
3604 mod_chanmode_free(change
);
3608 static CHANSERV_FUNC(cmd_myaccess
)
3610 static struct string_buffer sbuf
;
3611 struct handle_info
*target_handle
;
3612 struct userData
*uData
;
3615 target_handle
= user
->handle_info
;
3616 else if(!IsHelping(user
))
3618 reply("CSMSG_MYACCESS_SELF_ONLY", argv
[0]);
3621 else if(!(target_handle
= modcmd_get_handle_info(user
, argv
[1])))
3624 if(!target_handle
->channels
)
3626 reply("CSMSG_SQUAT_ACCESS", target_handle
->handle
);
3630 reply("CSMSG_INFOLINE_LIST", target_handle
->handle
);
3631 for(uData
= target_handle
->channels
; uData
; uData
= uData
->u_next
)
3633 struct chanData
*cData
= uData
->channel
;
3635 if(uData
->access
> UL_OWNER
)
3637 if(IsProtected(cData
)
3638 && (target_handle
!= user
->handle_info
)
3639 && !GetTrueChannelAccess(cData
, user
->handle_info
))
3642 string_buffer_append_printf(&sbuf
, "[%s (%d", cData
->channel
->name
, uData
->access
);
3643 if(uData
->flags
== USER_AUTO_OP
)
3644 string_buffer_append(&sbuf
, ',');
3645 if(IsUserSuspended(uData
))
3646 string_buffer_append(&sbuf
, 's');
3647 if(IsUserAutoOp(uData
))
3649 if(uData
->access
>= UL_OP
)
3650 string_buffer_append(&sbuf
, 'o');
3651 else if(uData
->access
>= UL_HALFOP
)
3652 string_buffer_append(&sbuf
, 'h');
3653 else if(uData
->access
>= UL_PEON
)
3654 string_buffer_append(&sbuf
, 'v');
3656 if(IsUserAutoInvite(uData
) && (uData
->access
>= cData
->lvlOpts
[lvlInviteMe
]))
3657 string_buffer_append(&sbuf
, 'i');
3659 string_buffer_append_printf(&sbuf
, ")] %s", uData
->info
);
3661 string_buffer_append_string(&sbuf
, ")]");
3662 string_buffer_append(&sbuf
, '\0');
3663 send_message_type(4, user
, cmd
->parent
->bot
, "%s", sbuf
.list
);
3669 static CHANSERV_FUNC(cmd_access
)
3671 struct userNode
*target
;
3672 struct handle_info
*target_handle
;
3673 struct userData
*uData
;
3675 char prefix
[MAXLEN
];
3680 target_handle
= target
->handle_info
;
3682 else if((target
= GetUserH(argv
[1])))
3684 target_handle
= target
->handle_info
;
3686 else if(argv
[1][0] == '*')
3688 if(!(target_handle
= get_handle_info(argv
[1]+1)))
3690 reply("MSG_HANDLE_UNKNOWN", argv
[1]+1);
3696 reply("MSG_NICK_UNKNOWN", argv
[1]);
3700 assert(target
|| target_handle
);
3702 if(target
== chanserv
)
3704 reply("CSMSG_IS_CHANSERV");
3712 reply("CSMSG_LAZY_SMURF_TARGET", target
->nick
, chanserv_conf
.irc_operator_epithet
);
3717 reply("MSG_USER_AUTHENTICATE", target
->nick
);
3720 reply("MSG_AUTHENTICATE");
3726 const char *epithet
= NULL
, *type
= NULL
;
3729 epithet
= chanserv_conf
.irc_operator_epithet
;
3732 else if(IsNetworkHelper(target
))
3734 epithet
= chanserv_conf
.network_helper_epithet
;
3735 type
= "network helper";
3737 else if(IsSupportHelper(target
))
3739 epithet
= chanserv_conf
.support_helper_epithet
;
3740 type
= "support helper";
3744 if(target_handle
->epithet
)
3745 reply("CSMSG_SMURF_TARGET", target
->nick
, target_handle
->epithet
, type
);
3747 reply("CSMSG_SMURF_TARGET", target
->nick
, epithet
, type
);
3749 sprintf(prefix
, "%s (%s)", target
->nick
, target_handle
->handle
);
3753 sprintf(prefix
, "%s", target_handle
->handle
);
3756 if(!channel
->channel_info
)
3758 reply("CSMSG_NOT_REGISTERED", channel
->name
);
3762 helping
= HANDLE_FLAGGED(target_handle
, HELPING
)
3763 && ((target_handle
->opserv_level
>= chanserv_conf
.nodelete_level
) || !IsProtected(channel
->channel_info
));
3764 if((uData
= GetTrueChannelAccess(channel
->channel_info
, target_handle
)))
3766 reply((helping
? "CSMSG_HELPER_HAS_ACCESS" : "CSMSG_USER_HAS_ACCESS"), prefix
, user_level_name_from_level(uData
->access
), uData
->access
, channel
->name
);
3767 /* To prevent possible information leaks, only show infolines
3768 * if the requestor is in the channel or it's their own
3770 if(uData
->info
&& (GetUserMode(channel
, user
) || (target_handle
== user
->handle_info
)))
3772 send_message_type(4, user
, cmd
->parent
->bot
, "[%s] %s", (target
? target
->nick
: target_handle
->handle
), uData
->info
);
3774 /* Likewise, only say it's suspended if the user has active
3775 * access in that channel or it's their own entry. */
3776 if(IsUserSuspended(uData
)
3777 && (GetChannelUser(channel
->channel_info
, user
->handle_info
)
3778 || (user
->handle_info
== uData
->handle
)))
3780 reply("CSMSG_USER_SUSPENDED", (target
? target
->nick
: target_handle
->handle
), channel
->name
);
3785 reply((helping
? "CSMSG_HELPER_NO_ACCESS" : "CSMSG_USER_NO_ACCESS"), prefix
, channel
->name
);
3791 /* This is never used...
3793 zoot_list(struct listData *list)
3795 struct userData *uData;
3796 unsigned int start, curr, highest, lowest;
3797 struct helpfile_table tmp_table;
3798 const char **temp, *msg;
3800 if(list->table.length == 1)
3803 send_message(list->user, list->bot, "CSMSG_ACCESS_SEARCH_HEADER", list->channel->name, user_level_name_from_level(list->lowest), user_level_name_from_level(list->highest), list->search);
3805 send_message(list->user, list->bot, "CSMSG_ACCESS_ALL_HEADER", list->channel->name, user_level_name_from_level(list->lowest), user_level_name_from_level(list->highest));
3806 msg = user_find_message(list->user, "MSG_NONE");
3807 send_message_type(4, list->user, list->bot, " %s", msg);
3809 tmp_table.width = list->table.width;
3810 tmp_table.flags = list->table.flags;
3811 list->table.contents[0][0] = " ";
3812 highest = list->highest;
3813 if(list->lowest != 0)
3814 lowest = list->lowest;
3815 else if(highest < 100)
3818 lowest = highest - 100;
3819 for(start = curr = 1; curr < list->table.length; )
3821 uData = list->users[curr-1];
3822 list->table.contents[curr++][0] = " ";
3823 if((curr == list->table.length) || (list->users[curr-1]->access < lowest))
3826 send_message(list->user, list->bot, "CSMSG_ACCESS_SEARCH_HEADER", list->channel->name, user_level_name_from_level(lowest), user_level_name_from_level(highest), list->search);
3828 send_message(list->user, list->bot, "CSMSG_ACCESS_ALL_HEADER", list->channel->name, user_level_name_from_level(lowest), user_level_name_from_level(highest));
3829 temp = list->table.contents[--start];
3830 list->table.contents[start] = list->table.contents[0];
3831 tmp_table.contents = list->table.contents + start;
3832 tmp_table.length = curr - start;
3833 table_send(list->bot, list->user->nick, 0, NULL, tmp_table);
3834 list->table.contents[start] = temp;
3836 highest = lowest - 1;
3837 lowest = (highest < 100) ? 0 : (highest - 99);
3844 def_list(struct listData
*list
)
3848 send_message(list
->user
, list
->bot
, "CSMSG_ACCESS_SEARCH_HEADER", list
->channel
->name
, user_level_name_from_level(list
->lowest
), user_level_name_from_level(list
->highest
), list
->search
);
3850 send_message(list
->user
, list
->bot
, "CSMSG_ACCESS_ALL_HEADER", list
->channel
->name
, user_level_name_from_level(list
->lowest
), user_level_name_from_level(list
->highest
));
3851 if(list
->table
.length
== 1)
3853 msg
= user_find_message(list
->user
, "MSG_NONE");
3854 send_message_type(4, list
->user
, list
->bot
, " %s", msg
);
3857 table_send(list
->bot
, list
->user
->nick
, 0, NULL
, list
->table
);
3861 userData_access_comp(const void *arg_a
, const void *arg_b
)
3863 const struct userData
*a
= *(struct userData
**)arg_a
;
3864 const struct userData
*b
= *(struct userData
**)arg_b
;
3866 if(a
->access
!= b
->access
)
3867 res
= b
->access
- a
->access
;
3869 res
= irccasecmp(a
->handle
->handle
, b
->handle
->handle
);
3874 cmd_list_users(struct userNode
*user
, struct chanNode
*channel
, unsigned int argc
, char *argv
[], struct svccmd
*cmd
, unsigned short lowest
, unsigned short highest
)
3876 void (*send_list
)(struct listData
*);
3877 struct userData
*uData
;
3878 struct listData lData
;
3879 unsigned int matches
;
3883 lData
.bot
= cmd
->parent
->bot
;
3884 lData
.channel
= channel
;
3885 lData
.lowest
= lowest
;
3886 lData
.highest
= highest
;
3887 lData
.search
= (argc
> 1) ? argv
[1] : NULL
;
3888 send_list
= def_list
;
3889 /* What does the following line do exactly?? */
3890 /*(void)zoot_list; ** since it doesn't show user levels */
3892 /* this does nothing!! -rubin
3893 if(user->handle_info)
3895 switch(user->handle_info->userlist_style)
3897 case HI_STYLE_DEF: send_list = def_list; break;
3898 case HI_STYLE_ZOOT: send_list = def_list; break;
3903 lData
.users
= alloca(channel
->channel_info
->userCount
* sizeof(struct userData
*));
3905 for(uData
= channel
->channel_info
->users
; uData
; uData
= uData
->next
)
3907 if((uData
->access
< lowest
)
3908 || (uData
->access
> highest
)
3909 || (lData
.search
&& !match_ircglob(uData
->handle
->handle
, lData
.search
)))
3911 lData
.users
[matches
++] = uData
;
3913 qsort(lData
.users
, matches
, sizeof(lData
.users
[0]), userData_access_comp
);
3915 lData
.table
.length
= matches
+1;
3916 lData
.table
.width
= 5;
3917 lData
.table
.flags
= TABLE_NO_FREE
;
3918 lData
.table
.contents
= malloc(lData
.table
.length
*sizeof(*lData
.table
.contents
));
3919 ary
= malloc(lData
.table
.width
*sizeof(**lData
.table
.contents
));
3920 lData
.table
.contents
[0] = ary
;
3924 ary
[3] = "Last Seen";
3926 for(matches
= 1; matches
< lData
.table
.length
; ++matches
)
3928 struct userData
*uData
= lData
.users
[matches
-1];
3929 char seen
[INTERVALLEN
];
3931 ary
= malloc(lData
.table
.width
*sizeof(**lData
.table
.contents
));
3932 lData
.table
.contents
[matches
] = ary
;
3933 /* ary[0] = strtab(uData->access);*/
3934 ary
[0] = user_level_name_from_level(uData
->access
);
3935 ary
[1] = strtab(uData
->access
);
3936 ary
[2] = uData
->handle
->handle
;
3939 else if(!uData
->seen
)
3942 ary
[3] = intervalString(seen
, now
- uData
->seen
, user
->handle_info
);
3943 ary
[3] = strdup(ary
[3]);
3944 if(IsUserSuspended(uData
))
3945 ary
[4] = "Suspended";
3946 else if(HANDLE_FLAGGED(uData
->handle
, FROZEN
))
3947 ary
[4] = "Vacation";
3952 for(matches
= 1; matches
< lData
.table
.length
; ++matches
)
3954 free((char*)lData
.table
.contents
[matches
][3]);
3955 free(lData
.table
.contents
[matches
]);
3957 free(lData
.table
.contents
[0]);
3958 free(lData
.table
.contents
);
3962 /* Remove this now that debugging is over? or improve it for
3963 * users? Would it be better tied into USERS somehow? -Rubin */
3964 static CHANSERV_FUNC(cmd_pending
)
3966 struct adduserPending
*ap
;
3967 reply("CSMSG_ADDUSER_PENDING_HEADER");
3969 for(ap
= adduser_pendings
;ap
;ap
= ap
->next
)
3970 reply("CSMSG_ADDUSER_PENDING_LIST", ap
->channel
->name
, ap
->user
->nick
);
3971 reply("CSMSG_ADDUSER_PENDING_FOOTER");
3975 static CHANSERV_FUNC(cmd_users
)
3977 return cmd_list_users(CSFUNC_ARGS
, 1, UL_OWNER
);
3980 static CHANSERV_FUNC(cmd_wlist
)
3982 return cmd_list_users(CSFUNC_ARGS
, UL_OWNER
, UL_OWNER
);
3985 static CHANSERV_FUNC(cmd_clist
)
3987 return cmd_list_users(CSFUNC_ARGS
, UL_COOWNER
, UL_OWNER
-1);
3990 static CHANSERV_FUNC(cmd_mlist
)
3992 return cmd_list_users(CSFUNC_ARGS
, UL_MANAGER
, UL_COOWNER
-1);
3995 static CHANSERV_FUNC(cmd_olist
)
3997 return cmd_list_users(CSFUNC_ARGS
, UL_OP
, UL_MANAGER
-1);
4000 static CHANSERV_FUNC(cmd_hlist
)
4002 return cmd_list_users(CSFUNC_ARGS
, UL_HALFOP
, UL_OP
-1);
4005 static CHANSERV_FUNC(cmd_plist
)
4007 return cmd_list_users(CSFUNC_ARGS
, 1, UL_HALFOP
-1);
4010 static CHANSERV_FUNC(cmd_lamers
)
4012 struct helpfile_table tbl
;
4013 unsigned int matches
= 0, timed
= 0, ii
;
4014 char t_buffer
[INTERVALLEN
], e_buffer
[INTERVALLEN
], *search
;
4015 const char *msg_never
, *triggered
, *expires
;
4016 struct banData
*ban
, **bans
; /* lamers */
4023 reply("CSMSG_LAMERS_HEADER", channel
->name
);
4024 bans
= alloca(channel
->channel_info
->banCount
* sizeof(struct banData
*)); /* lamers */
4027 for(ban
= channel
->channel_info
->bans
; ban
; ban
= ban
->next
)
4029 if(search
&& !match_ircglobs(search
, ban
->mask
))
4031 bans
[matches
++] = ban
;
4036 tbl
.length
= matches
+ 1;
4037 tbl
.width
= 4 + timed
;
4039 tbl
.flags
= TABLE_NO_FREE
;
4040 tbl
.contents
= malloc(tbl
.length
* sizeof(tbl
.contents
[0]));
4041 tbl
.contents
[0] = malloc(tbl
.width
* sizeof(tbl
.contents
[0][0]));
4042 tbl
.contents
[0][0] = "Mask";
4043 tbl
.contents
[0][1] = "Set By";
4044 tbl
.contents
[0][2] = "Triggered";
4047 tbl
.contents
[0][3] = "Expires";
4048 tbl
.contents
[0][4] = "Reason";
4051 tbl
.contents
[0][3] = "Reason";
4054 table_send(cmd
->parent
->bot
, user
->nick
, 0, NULL
, tbl
);
4056 free(tbl
.contents
[0]);
4061 msg_never
= user_find_message(user
, "MSG_NEVER");
4062 for(ii
= 0; ii
< matches
; )
4068 else if(ban
->expires
)
4069 expires
= intervalString(e_buffer
, ban
->expires
- now
, user
->handle_info
);
4071 expires
= msg_never
;
4074 triggered
= intervalString(t_buffer
, now
- ban
->triggered
, user
->handle_info
);
4076 triggered
= msg_never
;
4078 tbl
.contents
[++ii
] = malloc(tbl
.width
* sizeof(tbl
.contents
[0][0]));
4079 tbl
.contents
[ii
][0] = ban
->mask
;
4080 tbl
.contents
[ii
][1] = ban
->owner
;
4081 tbl
.contents
[ii
][2] = strdup(triggered
);
4084 tbl
.contents
[ii
][3] = strdup(expires
);
4085 tbl
.contents
[ii
][4] = ban
->reason
;
4088 tbl
.contents
[ii
][3] = ban
->reason
;
4090 table_send(cmd
->parent
->bot
, user
->nick
, 0, NULL
, tbl
);
4091 /* reply("MSG_MATCH_COUNT", matches); */
4092 for(ii
= 1; ii
< tbl
.length
; ++ii
)
4094 free((char*)tbl
.contents
[ii
][2]);
4096 free((char*)tbl
.contents
[ii
][3]);
4097 free(tbl
.contents
[ii
]);
4099 free(tbl
.contents
[0]);
4106 * return + if the user does NOT have the right to set the topic, and
4107 * the topic is changed.
4110 bad_topic(struct chanNode
*channel
, struct userNode
*user
, const char *new_topic
)
4112 struct chanData
*cData
= channel
->channel_info
;
4113 if(check_user_level(channel
, user
, lvlEnfTopic
, 1, 0))
4115 else if(cData
->topic
)
4116 return irccasecmp(new_topic
, cData
->topic
);
4123 * Makes a givin topic fit into a givin topic mask and returns
4126 * topic_mask - the mask to conform to
4127 * topic - the topic to make conform
4128 * new_topic - the pre-allocated char* to put the new topic into
4130 * modifies: new_topic
4133 conform_topic(char* topic_mask
, char* topic
, char *new_topic
)
4135 //char *topic_mask = cData->topic_mask;
4137 int pos
=0, starpos
=-1, dpos
=0, len
;
4139 while((tchar
= topic_mask
[pos
++]) && (dpos
<= TOPICLEN
))
4146 strcpy(new_topic
, "");
4149 len
= strlen(topic
);
4150 if((dpos
+ len
) > TOPICLEN
)
4151 len
= TOPICLEN
+ 1 - dpos
;
4152 memcpy(new_topic
+dpos
, topic
, len
);
4156 case '\\': tchar
= topic_mask
[pos
++]; /* and fall through */
4157 default: new_topic
[dpos
++] = tchar
; break;
4160 if((dpos
> TOPICLEN
) || tchar
)
4162 strcpy(new_topic
, "");
4165 new_topic
[dpos
] = 0;
4169 static CHANSERV_FUNC(cmd_topic
)
4171 struct chanData
*cData
;
4174 cData
= channel
->channel_info
;
4179 SetChannelTopic(channel
, chanserv
, cData
->topic
, 1);
4180 reply("CSMSG_TOPIC_SET", cData
->topic
);
4184 reply("CSMSG_NO_TOPIC", channel
->name
);
4188 topic
= unsplit_string(argv
+ 1, argc
- 1, NULL
);
4189 /* If they say "!topic *", use an empty topic. */
4190 if((topic
[0] == '*') && (topic
[1] == 0))
4193 if(bad_topic(channel
, user
, topic
))
4195 reply("CSMSG_TOPIC_LOCKED", channel
->name
);
4200 /* If there is a topicmask set, and the new topic doesnt match, make it */
4201 if(cData
->topic_mask
&& !match_ircglob(topic
, cData
->topic_mask
))
4203 char *topic_mask
= cData
->topic_mask
;
4204 char new_topic
[TOPICLEN
+1];
4206 /* make a new topic fitting mask */
4207 conform_topic(topic_mask
, topic
, new_topic
);
4210 /* Topic couldnt fit into mask, was too long */
4211 reply("CSMSG_TOPICMASK_CONFLICT1", channel
->name
, topic_mask
);
4212 reply("CSMSG_TOPICMASK_CONFLICT2", TOPICLEN
);
4215 SetChannelTopic(channel
, chanserv
, new_topic
, 1);
4217 else /* No mask set, just set the topic */
4218 SetChannelTopic(channel
, chanserv
, topic
, 1);
4221 if(check_user_level(channel
, user
, lvlTopicSnarf
, 1, 0))
4223 /* Grab the topic and save it as the default topic. */
4225 cData
->topic
= strdup(channel
->topic
);
4231 static CHANSERV_FUNC(cmd_mode
)
4233 struct mod_chanmode
*change
;
4237 change
= &channel
->channel_info
->modes
;
4238 if(change
->modes_set
|| change
->modes_clear
) {
4239 modcmd_chanmode_announce(change
);
4240 reply("CSMSG_DEFAULTED_MODES", channel
->name
);
4242 reply("CSMSG_NO_MODES", channel
->name
);
4246 change
= mod_chanmode_parse(channel
, argv
+1, argc
-1, MCP_KEY_FREE
|MCP_REGISTERED
);
4249 reply("MSG_INVALID_MODES", unsplit_string(argv
+1, argc
-1, NULL
));
4253 if(!check_user_level(channel
, user
, lvlEnfModes
, 1, 0)
4254 && mode_lock_violated(&channel
->channel_info
->modes
, change
))
4257 mod_chanmode_format(&channel
->channel_info
->modes
, modes
);
4258 reply("CSMSG_MODE_LOCKED", modes
, channel
->name
);
4262 modcmd_chanmode_announce(change
);
4263 mod_chanmode_free(change
);
4264 reply("CSMSG_MODES_SET", unsplit_string(argv
+1, argc
-1, NULL
));
4268 static CHANSERV_FUNC(cmd_invite
)
4270 struct userData
*uData
;
4271 struct userNode
*invite
;
4273 uData
= GetChannelUser(channel
->channel_info
, user
->handle_info
);
4277 if(!(invite
= GetUserH(argv
[1])))
4279 reply("MSG_NICK_UNKNOWN", argv
[1]);
4286 if(GetUserMode(channel
, invite
))
4288 reply("CSMSG_ALREADY_PRESENT", invite
->nick
, channel
->name
);
4296 char *reason
= unsplit_string(argv
+ 2, argc
- 2, NULL
);
4297 send_message(invite
, chanserv
, "CSMSG_INVITING_YOU_REASON", user
->nick
, channel
->name
, reason
);
4300 send_message(invite
, chanserv
, "CSMSG_INVITING_YOU", user
->nick
, channel
->name
);
4302 irc_invite(chanserv
, invite
, channel
);
4304 reply("CSMSG_INVITED_USER", argv
[1], channel
->name
);
4309 static CHANSERV_FUNC(cmd_inviteme
)
4311 if(GetUserMode(channel
, user
))
4313 reply("CSMSG_YOU_ALREADY_PRESENT", channel
->name
);
4316 if(channel
->channel_info
4317 && !check_user_level(channel
, user
, lvlInviteMe
, 1, 0))
4319 reply("CSMSG_LOW_CHANNEL_ACCESS", channel
->name
);
4322 irc_invite(cmd
->parent
->bot
, user
, channel
);
4327 show_suspension_info(struct svccmd
*cmd
, struct userNode
*user
, struct suspended
*suspended
)
4330 char buf1
[INTERVALLEN
], buf2
[INTERVALLEN
];
4332 /* We display things based on two dimensions:
4333 * - Issue time: present or absent
4334 * - Expiration: revoked, expired, expires in future, or indefinite expiration
4335 * (in order of precedence, so something both expired and revoked
4336 * only counts as revoked)
4338 combo
= (suspended
->issued
? 4 : 0)
4339 + (suspended
->revoked
? 3 : suspended
->expires
? ((suspended
->expires
< now
) ? 2 : 1) : 0);
4341 case 0: /* no issue time, indefinite expiration */
4342 reply("CSMSG_CHANNEL_SUSPENDED_0", suspended
->suspender
, suspended
->reason
);
4344 case 1: /* no issue time, expires in future */
4345 intervalString(buf1
, suspended
->expires
-now
, user
->handle_info
);
4346 reply("CSMSG_CHANNEL_SUSPENDED_1", suspended
->suspender
, buf1
, suspended
->reason
);
4348 case 2: /* no issue time, expired */
4349 intervalString(buf1
, now
-suspended
->expires
, user
->handle_info
);
4350 reply("CSMSG_CHANNEL_SUSPENDED_2", suspended
->suspender
, buf1
, suspended
->reason
);
4352 case 3: /* no issue time, revoked */
4353 intervalString(buf1
, now
-suspended
->revoked
, user
->handle_info
);
4354 reply("CSMSG_CHANNEL_SUSPENDED_3", suspended
->suspender
, buf1
, suspended
->reason
);
4356 case 4: /* issue time set, indefinite expiration */
4357 intervalString(buf1
, now
-suspended
->issued
, user
->handle_info
);
4358 reply("CSMSG_CHANNEL_SUSPENDED_4", buf1
, suspended
->suspender
, suspended
->reason
);
4360 case 5: /* issue time set, expires in future */
4361 intervalString(buf1
, now
-suspended
->issued
, user
->handle_info
);
4362 intervalString(buf2
, suspended
->expires
-now
, user
->handle_info
);
4363 reply("CSMSG_CHANNEL_SUSPENDED_5", buf1
, suspended
->suspender
, buf2
, suspended
->reason
);
4365 case 6: /* issue time set, expired */
4366 intervalString(buf1
, now
-suspended
->issued
, user
->handle_info
);
4367 intervalString(buf2
, now
-suspended
->expires
, user
->handle_info
);
4368 reply("CSMSG_CHANNEL_SUSPENDED_6", buf1
, suspended
->suspender
, buf2
, suspended
->reason
);
4370 case 7: /* issue time set, revoked */
4371 intervalString(buf1
, now
-suspended
->issued
, user
->handle_info
);
4372 intervalString(buf2
, now
-suspended
->revoked
, user
->handle_info
);
4373 reply("CSMSG_CHANNEL_SUSPENDED_7", buf1
, suspended
->suspender
, buf2
, suspended
->reason
);
4376 log_module(CS_LOG
, LOG_ERROR
, "Invalid combo value %d in show_suspension_info()", combo
);
4381 static CHANSERV_FUNC(cmd_info
)
4383 char modes
[MAXLEN
], buffer
[INTERVALLEN
];
4384 struct userData
*uData
, *owner
;
4385 struct chanData
*cData
;
4386 struct do_not_register
*dnr
;
4391 cData
= channel
->channel_info
;
4392 reply("CSMSG_CHANNEL_INFO", channel
->name
);
4395 uData
= GetChannelUser(cData
, user
->handle_info
);
4396 if(uData
&& (uData
->access
>= UL_OP
/*cData->lvlOpts[lvlGiveOps]*/))
4398 mod_chanmode_format(&cData
->modes
, modes
);
4399 reply("CSMSG_CHANNEL_TOPIC", cData
->topic
);
4400 reply("CSMSG_CHANNEL_MODES", modes
[0] ? modes
: user_find_message(user
, "MSG_NONE"));
4403 for(it
= dict_first(cData
->notes
); it
; it
= iter_next(it
))
4407 note
= iter_data(it
);
4408 if(!note_type_visible_to_user(cData
, note
->type
, user
))
4411 padding
= PADLEN
- 1 - strlen(iter_key(it
));
4412 reply("CSMSG_CHANNEL_NOTE", iter_key(it
), padding
> 0 ? padding
: 1, "", note
->note
);
4415 reply("CSMSG_CHANNEL_MAX", cData
->max
);
4416 for(owner
= cData
->users
; owner
; owner
= owner
->next
)
4417 if(owner
->access
== UL_OWNER
)
4418 reply("CSMSG_CHANNEL_OWNER", owner
->handle
->handle
);
4419 reply("CSMSG_CHANNEL_USERS", cData
->userCount
);
4420 reply("CSMSG_CHANNEL_LAMERS", cData
->banCount
);
4421 reply("CSMSG_CHANNEL_VISITED", intervalString(buffer
, now
- cData
->visited
, user
->handle_info
));
4422 reply("CSMSG_CHANNEL_REGISTERED", intervalString(buffer
, now
- cData
->registered
, user
->handle_info
));
4424 privileged
= IsStaff(user
);
4425 if(((uData
&& uData
->access
>= UL_COOWNER
) || privileged
) && cData
->registrar
)
4426 reply("CSMSG_CHANNEL_REGISTRAR", cData
->registrar
);
4428 if(privileged
&& (dnr
= chanserv_is_dnr(channel
->name
, NULL
)))
4429 chanserv_show_dnrs(user
, cmd
, channel
->name
, NULL
);
4431 if(cData
->suspended
&& ((uData
&& (uData
->access
>= UL_COOWNER
)) || IsHelping(user
)))
4433 struct suspended
*suspended
;
4434 reply((IsSuspended(cData
) ? "CSMSG_CHANNEL_SUSPENDED" : "CSMSG_CHANNEL_HISTORY"), channel
->name
);
4435 for(suspended
= cData
->suspended
; suspended
; suspended
= suspended
->previous
)
4436 show_suspension_info(cmd
, user
, suspended
);
4438 else if(IsSuspended(cData
))
4440 reply("CSMSG_CHANNEL_SUSPENDED", channel
->name
);
4441 show_suspension_info(cmd
, user
, cData
->suspended
);
4443 reply("CSMSG_CHANNEL_END");
4447 static CHANSERV_FUNC(cmd_netinfo
)
4449 extern time_t boot_time
;
4450 extern unsigned long burst_length
;
4451 char interval
[INTERVALLEN
];
4453 reply("CSMSG_NETWORK_INFO");
4454 reply("CSMSG_NETWORK_SERVERS", dict_size(servers
));
4455 reply("CSMSG_NETWORK_USERS", dict_size(clients
));
4456 reply("CSMSG_NETWORK_OPERS", curr_opers
.used
);
4457 reply("CSMSG_NETWORK_CHANNELS", registered_channels
);
4458 reply("CSMSG_NETWORK_LAMERS", banCount
);
4459 reply("CSMSG_NETWORK_CHANUSERS", userCount
);
4460 reply("CSMSG_SERVICES_UPTIME", intervalString(interval
, time(NULL
) - boot_time
, user
->handle_info
));
4461 reply("CSMSG_BURST_LENGTH", intervalString(interval
, burst_length
, user
->handle_info
));
4466 send_staff_list(struct userNode
*to
, struct userList
*list
, int skip_flags
)
4468 struct helpfile_table table
;
4470 struct userNode
*user
;
4475 table
.flags
= TABLE_REPEAT_ROWS
| TABLE_NO_FREE
| TABLE_NO_HEADERS
;
4476 table
.contents
= alloca(list
->used
*sizeof(*table
.contents
));
4477 for(nn
=0; nn
<list
->used
; nn
++)
4479 user
= list
->list
[nn
];
4480 if(user
->modes
& skip_flags
)
4484 table
.contents
[table
.length
] = alloca(table
.width
*sizeof(**table
.contents
));
4487 nick
= alloca(strlen(user
->nick
)+3);
4488 sprintf(nick
, "(%s)", user
->nick
);
4492 table
.contents
[table
.length
][0] = nick
;
4495 table_send(chanserv
, to
->nick
, 0, NULL
, table
);
4498 static CHANSERV_FUNC(cmd_ircops
)
4500 reply("CSMSG_STAFF_OPERS");
4501 send_staff_list(user
, &curr_opers
, FLAGS_SERVICE
);
4505 static CHANSERV_FUNC(cmd_helpers
)
4507 reply("CSMSG_STAFF_HELPERS");
4508 send_staff_list(user
, &curr_helpers
, FLAGS_OPER
);
4512 static CHANSERV_FUNC(cmd_staff
)
4514 reply("CSMSG_NETWORK_STAFF");
4515 cmd_ircops(CSFUNC_ARGS
);
4516 cmd_helpers(CSFUNC_ARGS
);
4520 static CHANSERV_FUNC(cmd_peek
)
4522 struct modeNode
*mn
;
4523 char modes
[MODELEN
];
4525 struct helpfile_table table
;
4527 irc_make_chanmode(channel
, modes
);
4529 reply("CSMSG_PEEK_INFO", channel
->name
);
4531 reply("CSMSG_PEEK_TOPIC", channel
->topic
);
4532 reply("CSMSG_PEEK_MODES", modes
);
4533 reply("CSMSG_PEEK_USERS", channel
->members
.used
);
4537 table
.flags
= TABLE_REPEAT_ROWS
| TABLE_NO_FREE
| TABLE_NO_HEADERS
;
4538 table
.contents
= alloca(channel
->members
.used
*sizeof(*table
.contents
));
4539 for(n
= 0; n
< channel
->members
.used
; n
++)
4541 mn
= channel
->members
.list
[n
];
4542 if(!(mn
->modes
& MODE_CHANOP
) || IsLocal(mn
->user
))
4544 table
.contents
[table
.length
] = alloca(sizeof(**table
.contents
));
4545 table
.contents
[table
.length
][0] = mn
->user
->nick
;
4550 reply("CSMSG_PEEK_OPS");
4551 table_send(chanserv
, user
->nick
, 0, NULL
, table
);
4554 reply("CSMSG_PEEK_NO_OPS");
4555 reply("CSMSG_PEEK_END");
4559 static MODCMD_FUNC(cmd_wipeinfo
)
4561 struct handle_info
*victim
;
4562 struct userData
*ud
, *actor
;
4565 actor
= GetChannelUser(channel
->channel_info
, user
->handle_info
);
4566 if(!(victim
= modcmd_get_handle_info(user
, argv
[1])))
4568 if(!(ud
= GetTrueChannelAccess(channel
->channel_info
, victim
)))
4570 reply("CSMSG_NO_CHAN_USER", argv
[1], channel
->name
);
4573 if((ud
->access
>= actor
->access
) && (ud
!= actor
))
4575 reply("MSG_USER_OUTRANKED", victim
->handle
);
4581 reply("CSMSG_WIPED_INFO_LINE", argv
[1], channel
->name
);
4585 static CHANSERV_FUNC(cmd_resync
)
4587 struct mod_chanmode
*changes
;
4588 struct chanData
*cData
= channel
->channel_info
;
4589 unsigned int ii
, used
;
4591 /* 6 = worst case -ovh+ovh on everyone */
4592 changes
= mod_chanmode_alloc(channel
->members
.used
* 6);
4593 for(ii
= used
= 0; ii
< channel
->members
.used
; ++ii
)
4595 struct modeNode
*mn
= channel
->members
.list
[ii
];
4596 struct userData
*uData
;
4598 if(IsService(mn
->user
))
4602 uData
= GetChannelAccess(cData
, mn
->user
->handle_info
);
4604 /* If the channel is in no-mode mode, de-mode EVERYONE */
4605 if(cData
->chOpts
[chAutomode
] == 'n')
4609 changes
->args
[used
].mode
= MODE_REMOVE
| mn
->modes
;
4610 changes
->args
[used
++].u
.member
= mn
;
4613 else /* Give various userlevels their modes.. */
4615 if(uData
&& uData
->access
>= UL_OP
)
4617 if(!(mn
->modes
& MODE_CHANOP
))
4619 changes
->args
[used
].mode
= MODE_CHANOP
;
4620 changes
->args
[used
++].u
.member
= mn
;
4623 else if(uData
&& uData
->access
>= UL_HALFOP
)
4625 if(mn
->modes
& MODE_CHANOP
)
4627 changes
->args
[used
].mode
= MODE_REMOVE
| MODE_CHANOP
;
4628 changes
->args
[used
++].u
.member
= mn
;
4630 if(!(mn
->modes
& MODE_HALFOP
))
4632 changes
->args
[used
].mode
= MODE_HALFOP
;
4633 changes
->args
[used
++].u
.member
= mn
;
4636 else if(uData
&& uData
->access
>= UL_PEON
)
4638 if(mn
->modes
& MODE_CHANOP
)
4640 changes
->args
[used
].mode
= MODE_REMOVE
| MODE_CHANOP
;
4641 changes
->args
[used
++].u
.member
= mn
;
4643 if(mn
->modes
& MODE_HALFOP
)
4645 changes
->args
[used
].mode
= MODE_REMOVE
| MODE_HALFOP
;
4646 changes
->args
[used
++].u
.member
= mn
;
4648 /* Don't voice peons if were in mode m */
4649 if( cData
->chOpts
[chAutomode
] == 'm')
4651 if(mn
->modes
& MODE_VOICE
)
4653 changes
->args
[used
].mode
= MODE_REMOVE
| MODE_VOICE
;
4654 changes
->args
[used
++].u
.member
= mn
;
4657 /* otherwise, make user they do have voice */
4658 else if(!(mn
->modes
& MODE_VOICE
))
4660 changes
->args
[used
].mode
= MODE_VOICE
;
4661 changes
->args
[used
++].u
.member
= mn
;
4664 else /* They arnt on the userlist.. */
4666 /* If we voice everyone, but they dont.. */
4667 if(cData
->chOpts
[chAutomode
] == 'v')
4669 /* Remove anything except v */
4670 if(mn
->modes
& ~MODE_VOICE
)
4672 changes
->args
[used
].mode
= MODE_REMOVE
| (mn
->modes
& ~MODE_VOICE
);
4673 changes
->args
[used
++].u
.member
= mn
;
4676 if(!(mn
->modes
& MODE_VOICE
))
4678 changes
->args
[used
].mode
= MODE_VOICE
;
4679 changes
->args
[used
++].u
.member
= mn
;
4682 /* If we hop everyone, but they dont.. */
4683 else if(cData
->chOpts
[chAutomode
] == 'h')
4685 /* Remove anything except h */
4686 if(mn
->modes
& ~MODE_HALFOP
)
4688 changes
->args
[used
].mode
= MODE_REMOVE
| (mn
->modes
& ~MODE_HALFOP
);
4689 changes
->args
[used
++].u
.member
= mn
;
4692 if(!(mn
->modes
& MODE_HALFOP
))
4694 changes
->args
[used
].mode
= MODE_HALFOP
;
4695 changes
->args
[used
++].u
.member
= mn
;
4698 /* If we op everyone, but they dont.. */
4699 else if(cData
->chOpts
[chAutomode
] == 'o')
4701 /* Remove anything except h */
4702 if(mn
->modes
& ~MODE_CHANOP
)
4704 changes
->args
[used
].mode
= MODE_REMOVE
| (mn
->modes
& ~MODE_CHANOP
);
4705 changes
->args
[used
++].u
.member
= mn
;
4708 if(!(mn
->modes
& MODE_CHANOP
))
4710 changes
->args
[used
].mode
= MODE_CHANOP
;
4711 changes
->args
[used
++].u
.member
= mn
;
4714 /* they have no excuse for having modes, de-everything them */
4719 changes
->args
[used
].mode
= MODE_REMOVE
| mn
->modes
;
4720 changes
->args
[used
++].u
.member
= mn
;
4726 changes
->argc
= used
;
4727 modcmd_chanmode_announce(changes
);
4728 mod_chanmode_free(changes
);
4729 reply("CSMSG_RESYNCED_USERS", channel
->name
);
4733 static CHANSERV_FUNC(cmd_seen
)
4735 struct userData
*uData
;
4736 struct handle_info
*handle
;
4737 char seen
[INTERVALLEN
];
4741 if(!irccasecmp(argv
[1], chanserv
->nick
))
4743 reply("CSMSG_IS_CHANSERV");
4747 if(!(handle
= get_handle_info(argv
[1])))
4749 reply("MSG_HANDLE_UNKNOWN", argv
[1]);
4753 if(!(uData
= GetTrueChannelAccess(channel
->channel_info
, handle
)))
4755 reply("CSMSG_NO_CHAN_USER", handle
->handle
, channel
->name
);
4760 reply("CSMSG_USER_PRESENT", handle
->handle
);
4761 else if(uData
->seen
)
4762 reply("CSMSG_USER_SEEN", handle
->handle
, channel
->name
, intervalString(seen
, now
- uData
->seen
, user
->handle_info
));
4764 reply("CSMSG_NEVER_SEEN", handle
->handle
, channel
->name
);
4766 if(!uData
->present
&& HANDLE_FLAGGED(handle
, FROZEN
))
4767 reply("CSMSG_USER_VACATION", handle
->handle
);
4772 static MODCMD_FUNC(cmd_names
)
4774 struct userNode
*targ
;
4775 struct userData
*targData
;
4776 unsigned int ii
, pos
;
4779 for(ii
=pos
=0; ii
<channel
->members
.used
; ++ii
)
4781 targ
= channel
->members
.list
[ii
]->user
;
4782 targData
= GetTrueChannelAccess(channel
->channel_info
, targ
->handle_info
);
4785 if(pos
+ strlen(targ
->nick
) + strlen(targ
->handle_info
->handle
) + 8 > sizeof(buf
))
4788 reply("CSMSG_CHANNEL_NAMES", channel
->name
, buf
);
4792 if(IsUserSuspended(targData
))
4794 pos
+= sprintf(buf
+pos
, "%d:%s(%s)", targData
->access
, targ
->nick
, targ
->handle_info
->handle
);
4797 reply("CSMSG_CHANNEL_NAMES", channel
->name
, buf
);
4798 reply("CSMSG_END_NAMES", channel
->name
);
4803 note_type_visible_to_user(struct chanData
*channel
, struct note_type
*ntype
, struct userNode
*user
)
4805 switch(ntype
->visible_type
)
4807 case NOTE_VIS_ALL
: return 1;
4808 case NOTE_VIS_CHANNEL_USERS
: return !channel
|| !user
|| (user
->handle_info
&& GetChannelUser(channel
, user
->handle_info
));
4809 case NOTE_VIS_PRIVILEGED
: default: return user
&& (IsOper(user
) || IsSupportHelper(user
) || IsNetworkHelper(user
));
4814 note_type_settable_by_user(struct chanNode
*channel
, struct note_type
*ntype
, struct userNode
*user
)
4816 struct userData
*uData
;
4818 switch(ntype
->set_access_type
)
4820 case NOTE_SET_CHANNEL_ACCESS
:
4821 if(!user
->handle_info
)
4823 if(!(uData
= GetChannelUser(channel
->channel_info
, user
->handle_info
)))
4825 return uData
->access
>= ntype
->set_access
.min_ulevel
;
4826 case NOTE_SET_CHANNEL_SETTER
:
4827 return check_user_level(channel
, user
, lvlSetters
, 1, 0);
4828 case NOTE_SET_PRIVILEGED
: default:
4829 return IsHelping(user
) && (user
->handle_info
->opserv_level
>= ntype
->set_access
.min_opserv
);
4833 static CHANSERV_FUNC(cmd_note
)
4835 struct chanData
*cData
;
4837 struct note_type
*ntype
;
4839 cData
= channel
->channel_info
;
4842 reply("CSMSG_NOT_REGISTERED", channel
->name
);
4846 /* If no arguments, show all visible notes for the channel. */
4852 for(count
=0, it
=dict_first(cData
->notes
); it
; it
=iter_next(it
))
4854 note
= iter_data(it
);
4855 if(!note_type_visible_to_user(cData
, note
->type
, user
))
4858 reply("CSMSG_NOTELIST_HEADER", channel
->name
);
4859 reply("CSMSG_NOTE_FORMAT", iter_key(it
), note
->setter
, note
->note
);
4862 reply("CSMSG_NOTELIST_END", channel
->name
);
4864 reply("CSMSG_NOTELIST_EMPTY", channel
->name
);
4866 /* If one argument, show the named note. */
4869 if((note
= dict_find(cData
->notes
, argv
[1], NULL
))
4870 && note_type_visible_to_user(cData
, note
->type
, user
))
4872 reply("CSMSG_NOTE_FORMAT", note
->type
->name
, note
->setter
, note
->note
);
4874 else if((ntype
= dict_find(note_types
, argv
[1], NULL
))
4875 && note_type_visible_to_user(NULL
, ntype
, user
))
4877 reply("CSMSG_NO_SUCH_NOTE", channel
->name
, ntype
->name
);
4882 reply("CSMSG_BAD_NOTE_TYPE", argv
[1]);
4886 /* Assume they're trying to set a note. */
4890 ntype
= dict_find(note_types
, argv
[1], NULL
);
4893 reply("CSMSG_BAD_NOTE_TYPE", argv
[1]);
4896 else if(note_type_settable_by_user(channel
, ntype
, user
))
4898 note_text
= unsplit_string(argv
+2, argc
-2, NULL
);
4899 if((note
= dict_find(cData
->notes
, argv
[1], NULL
)))
4900 reply("CSMSG_REPLACED_NOTE", ntype
->name
, channel
->name
, note
->setter
, note
->note
);
4901 chanserv_add_channel_note(cData
, ntype
, user
->handle_info
->handle
, note_text
);
4902 reply("CSMSG_NOTE_SET", ntype
->name
, channel
->name
);
4904 if(ntype
->visible_type
== NOTE_VIS_PRIVILEGED
)
4906 /* The note is viewable to staff only, so return 0
4907 to keep the invocation from getting logged (or
4908 regular users can see it in !events). */
4914 reply("CSMSG_NO_ACCESS");
4921 static CHANSERV_FUNC(cmd_delnote
)
4926 if(!(note
= dict_find(channel
->channel_info
->notes
, argv
[1], NULL
))
4927 || !note_type_settable_by_user(channel
, note
->type
, user
))
4929 reply("CSMSG_NO_SUCH_NOTE", channel
->name
, argv
[1]);
4932 dict_remove(channel
->channel_info
->notes
, note
->type
->name
);
4933 reply("CSMSG_NOTE_REMOVED", argv
[1], channel
->name
);
4937 static CHANSERV_FUNC(cmd_last
)
4943 numoflines
= (argc
> 1) ? atoi(argv
[1]) : 10;
4945 if(numoflines
< 1 || numoflines
> 200)
4947 reply("CSMSG_LAST_INVALID");
4950 ShowLog(user
, channel
, "*", "*", "*", "*", numoflines
);
4954 static CHANSERV_FUNC(cmd_events
)
4956 struct logSearch discrim
;
4957 struct logReport report
;
4958 unsigned int matches
, limit
;
4960 limit
= (argc
> 1) ? atoi(argv
[1]) : 10;
4961 if(limit
< 1 || limit
> 200)
4964 memset(&discrim
, 0, sizeof(discrim
));
4965 discrim
.masks
.bot
= chanserv
;
4966 discrim
.masks
.channel_name
= channel
->name
;
4968 discrim
.masks
.command
= argv
[2];
4969 discrim
.limit
= limit
;
4970 discrim
.max_time
= INT_MAX
;
4971 discrim
.severities
= 1 << LOG_COMMAND
;
4972 report
.reporter
= chanserv
;
4974 reply("CSMSG_EVENT_SEARCH_RESULTS", channel
->name
);
4976 matches
= log_entry_search(&discrim
, log_report_entry
, &report
);
4978 reply("MSG_MATCH_COUNT", matches
);
4980 reply("MSG_NO_MATCHES");
4984 static CHANSERV_FUNC(cmd_say
)
4990 msg
= unsplit_string(argv
+ 1, argc
- 1, NULL
);
4991 send_channel_message(channel
, cmd
->parent
->bot
, "%s", msg
);
4993 else if(GetUserH(argv
[1]))
4996 msg
= unsplit_string(argv
+ 2, argc
- 2, NULL
);
4997 send_target_message(5, argv
[1], cmd
->parent
->bot
, "%s", msg
);
5001 reply("MSG_NOT_TARGET_NAME");
5007 static CHANSERV_FUNC(cmd_emote
)
5013 /* CTCP is so annoying. */
5014 msg
= unsplit_string(argv
+ 1, argc
- 1, NULL
);
5015 send_channel_message(channel
, cmd
->parent
->bot
, "\001ACTION %s\001", msg
);
5017 else if(GetUserH(argv
[1]))
5019 msg
= unsplit_string(argv
+ 2, argc
- 2, NULL
);
5020 send_target_message(5, argv
[1], cmd
->parent
->bot
, "\001ACTION %s\001", msg
);
5024 reply("MSG_NOT_TARGET_NAME");
5030 struct channelList
*
5031 chanserv_support_channels(void)
5033 return &chanserv_conf
.support_channels
;
5036 static CHANSERV_FUNC(cmd_expire
)
5038 int channel_count
= registered_channels
;
5039 expire_channels(NULL
);
5040 reply("CSMSG_CHANNELS_EXPIRED", channel_count
- registered_channels
);
5045 chanserv_expire_suspension(void *data
)
5047 struct suspended
*suspended
= data
;
5048 struct chanNode
*channel
;
5050 if(!suspended
->expires
|| (now
< suspended
->expires
))
5051 suspended
->revoked
= now
;
5052 channel
= suspended
->cData
->channel
;
5053 suspended
->cData
->channel
= channel
;
5054 suspended
->cData
->flags
&= ~CHANNEL_SUSPENDED
;
5055 if(!IsOffChannel(suspended
->cData
))
5057 struct mod_chanmode change
;
5058 mod_chanmode_init(&change
);
5060 change
.args
[0].mode
= MODE_CHANOP
;
5061 change
.args
[0].u
.member
= AddChannelUser(chanserv
, channel
);
5062 mod_chanmode_announce(chanserv
, channel
, &change
);
5066 static CHANSERV_FUNC(cmd_csuspend
)
5068 struct suspended
*suspended
;
5069 char reason
[MAXLEN
];
5070 time_t expiry
, duration
;
5071 struct userData
*uData
;
5075 if(IsProtected(channel
->channel_info
))
5077 reply("CSMSG_SUSPEND_NODELETE", channel
->name
);
5081 if(argv
[1][0] == '!')
5083 else if(IsSuspended(channel
->channel_info
))
5085 reply("CSMSG_ALREADY_SUSPENDED", channel
->name
);
5086 show_suspension_info(cmd
, user
, channel
->channel_info
->suspended
);
5090 if(!strcmp(argv
[1], "0"))
5092 else if((duration
= ParseInterval(argv
[1])))
5093 expiry
= now
+ duration
;
5096 reply("MSG_INVALID_DURATION", argv
[1]);
5100 unsplit_string(argv
+ 2, argc
- 2, reason
);
5102 suspended
= calloc(1, sizeof(*suspended
));
5103 suspended
->revoked
= 0;
5104 suspended
->issued
= now
;
5105 suspended
->suspender
= strdup(user
->handle_info
->handle
);
5106 suspended
->expires
= expiry
;
5107 suspended
->reason
= strdup(reason
);
5108 suspended
->cData
= channel
->channel_info
;
5109 suspended
->previous
= suspended
->cData
->suspended
;
5110 suspended
->cData
->suspended
= suspended
;
5112 if(suspended
->expires
)
5113 timeq_add(suspended
->expires
, chanserv_expire_suspension
, suspended
);
5115 if(IsSuspended(channel
->channel_info
))
5117 suspended
->previous
->revoked
= now
;
5118 if(suspended
->previous
->expires
)
5119 timeq_del(suspended
->previous
->expires
, chanserv_expire_suspension
, suspended
->previous
, 0);
5120 sprintf(reason
, "%s suspension modified by %s.", channel
->name
, suspended
->suspender
);
5121 global_message(MESSAGE_RECIPIENT_OPERS
| MESSAGE_RECIPIENT_HELPERS
, reason
);
5125 /* Mark all users in channel as absent. */
5126 for(uData
= channel
->channel_info
->users
; uData
; uData
= uData
->next
)
5135 /* Mark the channel as suspended, then part. */
5136 channel
->channel_info
->flags
|= CHANNEL_SUSPENDED
;
5137 DelChannelUser(chanserv
, channel
, suspended
->reason
, 0);
5138 reply("CSMSG_SUSPENDED", channel
->name
);
5139 sprintf(reason
, "%s suspended by %s.", channel
->name
, suspended
->suspender
);
5140 global_message(MESSAGE_RECIPIENT_OPERS
| MESSAGE_RECIPIENT_HELPERS
, reason
);
5145 static CHANSERV_FUNC(cmd_cunsuspend
)
5147 struct suspended
*suspended
;
5148 char message
[MAXLEN
];
5150 if(!IsSuspended(channel
->channel_info
))
5152 reply("CSMSG_NOT_SUSPENDED", channel
->name
);
5156 suspended
= channel
->channel_info
->suspended
;
5158 /* Expire the suspension and join ChanServ to the channel. */
5159 timeq_del(suspended
->expires
, chanserv_expire_suspension
, suspended
, 0);
5160 chanserv_expire_suspension(suspended
);
5161 reply("CSMSG_UNSUSPENDED", channel
->name
);
5162 sprintf(message
, "%s unsuspended by %s.", channel
->name
, user
->handle_info
->handle
);
5163 global_message(MESSAGE_RECIPIENT_OPERS
|MESSAGE_RECIPIENT_HELPERS
, message
);
5167 typedef struct chanservSearch
5175 unsigned long flags
;
5179 typedef void (*channel_search_func
)(struct chanData
*channel
, void *data
);
5182 chanserv_search_create(struct userNode
*user
, unsigned int argc
, char *argv
[])
5187 search
= malloc(sizeof(struct chanservSearch
));
5188 memset(search
, 0, sizeof(*search
));
5191 for(i
= 0; i
< argc
; i
++)
5193 /* Assume all criteria require arguments. */
5196 send_message(user
, chanserv
, "MSG_MISSING_PARAMS", argv
[i
]);
5200 if(!irccasecmp(argv
[i
], "name"))
5201 search
->name
= argv
[++i
];
5202 else if(!irccasecmp(argv
[i
], "registrar"))
5203 search
->registrar
= argv
[++i
];
5204 else if(!irccasecmp(argv
[i
], "unvisited"))
5205 search
->unvisited
= ParseInterval(argv
[++i
]);
5206 else if(!irccasecmp(argv
[i
], "registered"))
5207 search
->registered
= ParseInterval(argv
[++i
]);
5208 else if(!irccasecmp(argv
[i
], "flags"))
5211 if(!irccasecmp(argv
[i
], "nodelete"))
5212 search
->flags
|= CHANNEL_NODELETE
;
5213 else if(!irccasecmp(argv
[i
], "suspended"))
5214 search
->flags
|= CHANNEL_SUSPENDED
;
5217 send_message(user
, chanserv
, "CSMSG_INVALID_CFLAG", argv
[i
]);
5221 else if(!irccasecmp(argv
[i
], "limit"))
5222 search
->limit
= strtoul(argv
[++i
], NULL
, 10);
5225 send_message(user
, chanserv
, "MSG_INVALID_CRITERIA", argv
[i
]);
5230 if(search
->name
&& !strcmp(search
->name
, "*"))
5232 if(search
->registrar
&& !strcmp(search
->registrar
, "*"))
5233 search
->registrar
= 0;
5242 chanserv_channel_match(struct chanData
*channel
, search_t search
)
5244 const char *name
= channel
->channel
->name
;
5245 if((search
->name
&& !match_ircglob(name
, search
->name
)) ||
5246 (search
->registrar
&& !channel
->registrar
) ||
5247 (search
->registrar
&& !match_ircglob(channel
->registrar
, search
->registrar
)) ||
5248 (search
->unvisited
&& (now
- channel
->visited
) < search
->unvisited
) ||
5249 (search
->registered
&& (now
- channel
->registered
) > search
->registered
) ||
5250 (search
->flags
&& ((search
->flags
& channel
->flags
) != search
->flags
)))
5257 chanserv_channel_search(search_t search
, channel_search_func smf
, void *data
)
5259 struct chanData
*channel
;
5260 unsigned int matches
= 0;
5262 for(channel
= channelList
; channel
&& matches
< search
->limit
; channel
= channel
->next
)
5264 if(!chanserv_channel_match(channel
, search
))
5274 search_count(UNUSED_ARG(struct chanData
*channel
), UNUSED_ARG(void *data
))
5279 search_print(struct chanData
*channel
, void *data
)
5281 send_message_type(4, data
, chanserv
, "%s", channel
->channel
->name
);
5284 static CHANSERV_FUNC(cmd_search
)
5287 unsigned int matches
;
5288 channel_search_func action
;
5292 if(!irccasecmp(argv
[1], "count"))
5293 action
= search_count
;
5294 else if(!irccasecmp(argv
[1], "print"))
5295 action
= search_print
;
5298 reply("CSMSG_ACTION_INVALID", argv
[1]);
5302 search
= chanserv_search_create(user
, argc
- 2, argv
+ 2);
5306 if(action
== search_count
)
5307 search
->limit
= INT_MAX
;
5309 if(action
== search_print
)
5311 reply("CSMSG_CHANNEL_SEARCH_RESULTS");
5315 matches
= chanserv_channel_search(search
, action
, user
);
5318 reply("MSG_MATCH_COUNT", matches
);
5320 reply("MSG_NO_MATCHES");
5326 static CHANSERV_FUNC(cmd_unvisited
)
5328 struct chanData
*cData
;
5329 time_t interval
= chanserv_conf
.channel_expire_delay
;
5330 char buffer
[INTERVALLEN
];
5331 unsigned int limit
= 25, matches
= 0;
5335 interval
= ParseInterval(argv
[1]);
5337 limit
= atoi(argv
[2]);
5340 intervalString(buffer
, interval
, user
->handle_info
);
5341 reply("CSMSG_UNVISITED_HEADER", limit
, buffer
);
5343 for(cData
= channelList
; cData
&& matches
< limit
; cData
= cData
->next
)
5345 if((now
- cData
->visited
) < interval
)
5348 intervalString(buffer
, now
- cData
->visited
, user
->handle_info
);
5349 reply("CSMSG_UNVISITED_DATA", cData
->channel
->name
, buffer
);
5356 static MODCMD_FUNC(chan_opt_defaulttopic
)
5362 if(!check_user_level(channel
, user
, lvlEnfTopic
, 1, 0))
5364 reply("CSMSG_TOPIC_LOCKED", channel
->name
);
5368 topic
= unsplit_string(argv
+1, argc
-1, NULL
);
5370 free(channel
->channel_info
->topic
);
5371 if(topic
[0] == '*' && topic
[1] == 0)
5373 topic
= channel
->channel_info
->topic
= NULL
;
5377 topic
= channel
->channel_info
->topic
= strdup(topic
);
5378 if(channel
->channel_info
->topic_mask
5379 && !match_ircglob(channel
->channel_info
->topic
, channel
->channel_info
->topic_mask
))
5380 reply("CSMSG_TOPIC_MISMATCH", channel
->name
);
5382 SetChannelTopic(channel
, chanserv
, topic
? topic
: "", 1);
5385 if(channel
->channel_info
->topic
)
5386 reply("CSMSG_SET_DEFAULT_TOPIC", channel
->channel_info
->topic
);
5388 reply("CSMSG_SET_DEFAULT_TOPIC", user_find_message(user
, "MSG_NONE"));
5392 static MODCMD_FUNC(chan_opt_topicmask
)
5396 struct chanData
*cData
= channel
->channel_info
;
5399 if(!check_user_level(channel
, user
, lvlEnfTopic
, 1, 0))
5401 reply("CSMSG_TOPIC_LOCKED", channel
->name
);
5405 mask
= unsplit_string(argv
+1, argc
-1, NULL
);
5407 if(cData
->topic_mask
)
5408 free(cData
->topic_mask
);
5409 if(mask
[0] == '*' && mask
[1] == 0)
5411 cData
->topic_mask
= 0;
5415 cData
->topic_mask
= strdup(mask
);
5417 reply("CSMSG_MASK_BUT_NO_TOPIC", channel
->name
);
5418 else if(!match_ircglob(cData
->topic
, cData
->topic_mask
))
5419 reply("CSMSG_TOPIC_MISMATCH", channel
->name
);
5423 if(channel
->channel_info
->topic_mask
)
5424 reply("CSMSG_SET_TOPICMASK", channel
->channel_info
->topic_mask
);
5426 reply("CSMSG_SET_TOPICMASK", user_find_message(user
, "MSG_NONE"));
5430 int opt_greeting_common(struct userNode
*user
, struct svccmd
*cmd
, int argc
, char *argv
[], char *name
, char **data
)
5434 char *greeting
= unsplit_string(argv
+1, argc
-1, NULL
);
5438 if(greeting
[0] == '*' && greeting
[1] == 0)
5442 unsigned int length
= strlen(greeting
);
5443 if(length
> chanserv_conf
.greeting_length
)
5445 reply("CSMSG_GREETING_TOO_LONG", length
, chanserv_conf
.greeting_length
);
5448 *data
= strdup(greeting
);
5457 reply(name
, user_find_message(user
, "MSG_NONE"));
5461 static MODCMD_FUNC(chan_opt_greeting
)
5463 return opt_greeting_common(user
, cmd
, argc
, argv
, "CSMSG_SET_GREETING", &channel
->channel_info
->greeting
);
5466 static MODCMD_FUNC(chan_opt_usergreeting
)
5468 return opt_greeting_common(user
, cmd
, argc
, argv
, "CSMSG_SET_USERGREETING", &channel
->channel_info
->user_greeting
);
5471 static MODCMD_FUNC(chan_opt_modes
)
5473 struct mod_chanmode
*new_modes
;
5474 char modes
[MODELEN
];
5478 if(!check_user_level(channel
, user
, lvlEnfModes
, 1, 0))
5480 reply("CSMSG_NO_ACCESS");
5483 if(argv
[1][0] == '*' && argv
[1][1] == 0)
5485 memset(&channel
->channel_info
->modes
, 0, sizeof(channel
->channel_info
->modes
));
5487 else if(!(new_modes
= mod_chanmode_parse(channel
, argv
+1, argc
-1, MCP_KEY_FREE
|MCP_REGISTERED
)))
5489 reply("CSMSG_INVALID_MODE_LOCK", unsplit_string(argv
+1, argc
-1, NULL
));
5492 else if(new_modes
->argc
> 1)
5494 reply("CSMSG_INVALID_MODE_LOCK", unsplit_string(argv
+1, argc
-1, NULL
));
5495 mod_chanmode_free(new_modes
);
5500 channel
->channel_info
->modes
= *new_modes
;
5501 modcmd_chanmode_announce(new_modes
);
5502 mod_chanmode_free(new_modes
);
5506 mod_chanmode_format(&channel
->channel_info
->modes
, modes
);
5508 reply("CSMSG_SET_MODES", modes
);
5510 reply("CSMSG_SET_MODES", user_find_message(user
, "MSG_NONE"));
5514 #define CHANNEL_BINARY_OPTION(MSG, FLAG) return channel_binary_option(MSG, FLAG, CSFUNC_ARGS);
5516 channel_binary_option(char *name
, unsigned long mask
, struct userNode
*user
, struct chanNode
*channel
, int argc
, char *argv
[], struct svccmd
*cmd
)
5518 struct chanData
*cData
= channel
->channel_info
;
5523 /* Set flag according to value. */
5524 if(enabled_string(argv
[1]))
5526 cData
->flags
|= mask
;
5529 else if(disabled_string(argv
[1]))
5531 cData
->flags
&= ~mask
;
5536 reply("MSG_INVALID_BINARY", argv
[1]);
5542 /* Find current option value. */
5543 value
= (cData
->flags
& mask
) ? 1 : 0;
5547 reply(name
, user_find_message(user
, "MSG_ON"));
5549 reply(name
, user_find_message(user
, "MSG_OFF"));
5553 static MODCMD_FUNC(chan_opt_nodelete
)
5555 if((argc
> 1) && (!IsOper(user
) || !user
->handle_info
|| (user
->handle_info
->opserv_level
< chanserv_conf
.nodelete_level
)))
5557 reply("MSG_SETTING_PRIVILEGED", argv
[0]);
5561 CHANNEL_BINARY_OPTION("CSMSG_SET_NODELETE", CHANNEL_NODELETE
);
5564 static MODCMD_FUNC(chan_opt_dynlimit
)
5566 CHANNEL_BINARY_OPTION("CSMSG_SET_DYNLIMIT", CHANNEL_DYNAMIC_LIMIT
);
5569 static MODCMD_FUNC(chan_opt_offchannel
)
5571 struct chanData
*cData
= channel
->channel_info
;
5576 /* Set flag according to value. */
5577 if(enabled_string(argv
[1]))
5579 if(!IsOffChannel(cData
))
5580 DelChannelUser(chanserv
, channel
, "Going off-channel.", 0);
5581 cData
->flags
|= CHANNEL_OFFCHANNEL
;
5584 else if(disabled_string(argv
[1]))
5586 if(IsOffChannel(cData
))
5588 struct mod_chanmode change
;
5589 mod_chanmode_init(&change
);
5591 change
.args
[0].mode
= MODE_CHANOP
;
5592 change
.args
[0].u
.member
= AddChannelUser(chanserv
, channel
);
5593 mod_chanmode_announce(chanserv
, channel
, &change
);
5595 cData
->flags
&= ~CHANNEL_OFFCHANNEL
;
5600 reply("MSG_INVALID_BINARY", argv
[1]);
5606 /* Find current option value. */
5607 value
= (cData
->flags
& CHANNEL_OFFCHANNEL
) ? 1 : 0;
5611 reply("CSMSG_SET_OFFCHANNEL", user_find_message(user
, "MSG_ON"));
5613 reply("CSMSG_SET_OFFCHANNEL", user_find_message(user
, "MSG_OFF"));
5617 static MODCMD_FUNC(chan_opt_defaults
)
5619 struct userData
*uData
;
5620 struct chanData
*cData
;
5621 const char *confirm
;
5622 enum levelOption lvlOpt
;
5623 enum charOption chOpt
;
5625 cData
= channel
->channel_info
;
5626 uData
= GetChannelUser(cData
, user
->handle_info
);
5627 if(!uData
|| (uData
->access
< UL_OWNER
))
5629 reply("CSMSG_OWNER_DEFAULTS", channel
->name
);
5632 confirm
= make_confirmation_string(uData
);
5633 if((argc
< 2) || strcmp(argv
[1], confirm
))
5635 reply("CSMSG_CONFIRM_DEFAULTS", channel
->name
, confirm
);
5638 cData
->flags
= CHANNEL_DEFAULT_FLAGS
;
5639 cData
->modes
= chanserv_conf
.default_modes
;
5640 for(lvlOpt
= 0; lvlOpt
< NUM_LEVEL_OPTIONS
; ++lvlOpt
)
5641 cData
->lvlOpts
[lvlOpt
] = levelOptions
[lvlOpt
].default_value
;
5642 for(chOpt
= 0; chOpt
< NUM_CHAR_OPTIONS
; ++chOpt
)
5643 cData
->chOpts
[chOpt
] = charOptions
[chOpt
].default_value
;
5644 reply("CSMSG_SETTINGS_DEFAULTED", channel
->name
);
5649 channel_level_option(enum levelOption option
, struct userNode
*user
, struct chanNode
*channel
, int argc
, char *argv
[], struct svccmd
*cmd
)
5651 struct chanData
*cData
= channel
->channel_info
;
5652 struct userData
*uData
;
5653 unsigned short value
;
5657 if(!check_user_level(channel
, user
, option
, 1, 1))
5659 reply("CSMSG_CANNOT_SET");
5662 value
= user_level_from_name(argv
[1], UL_OWNER
+1);
5663 if(!value
&& strcmp(argv
[1], "0"))
5665 reply("CSMSG_INVALID_ACCESS", argv
[1]);
5668 uData
= GetChannelUser(cData
, user
->handle_info
);
5669 if(!uData
|| ((uData
->access
< UL_OWNER
) && (value
> uData
->access
)))
5671 reply("CSMSG_BAD_SETLEVEL");
5677 /* This test only applies to owners, since non-owners
5678 * trying to set an option to above their level get caught
5679 * by the CSMSG_BAD_SETLEVEL test above.
5681 if(value
> uData
->access
)
5683 reply("CSMSG_BAD_SETTERS");
5690 cData
->lvlOpts
[option
] = value
;
5692 reply(levelOptions
[option
].format_name
, cData
->lvlOpts
[option
]);
5696 static MODCMD_FUNC(chan_opt_enfops
)
5698 return channel_level_option(lvlEnfOps
, CSFUNC_ARGS
);
5701 static MODCMD_FUNC(chan_opt_enfhalfops
)
5703 return channel_level_option(lvlEnfHalfOps
, CSFUNC_ARGS
);
5705 static MODCMD_FUNC(chan_opt_enfmodes
)
5707 return channel_level_option(lvlEnfModes
, CSFUNC_ARGS
);
5710 static MODCMD_FUNC(chan_opt_enftopic
)
5712 return channel_level_option(lvlEnfTopic
, CSFUNC_ARGS
);
5715 static MODCMD_FUNC(chan_opt_pubcmd
)
5717 return channel_level_option(lvlPubCmd
, CSFUNC_ARGS
);
5720 static MODCMD_FUNC(chan_opt_setters
)
5722 return channel_level_option(lvlSetters
, CSFUNC_ARGS
);
5725 static MODCMD_FUNC(chan_opt_userinfo
)
5727 return channel_level_option(lvlUserInfo
, CSFUNC_ARGS
);
5730 static MODCMD_FUNC(chan_opt_topicsnarf
)
5732 return channel_level_option(lvlTopicSnarf
, CSFUNC_ARGS
);
5735 static MODCMD_FUNC(chan_opt_inviteme
)
5737 return channel_level_option(lvlInviteMe
, CSFUNC_ARGS
);
5740 /* TODO: Make look like this when no args are
5742 * -X3- -------------------------------
5743 * -X3- BanTimeout: Bans are removed:
5744 * -X3- ----- * indicates current -----
5745 * -X3- 0: [*] Never.
5746 * -X3- 1: [ ] After 10 minutes.
5747 * -X3- 2: [ ] After 2 hours.
5748 * -X3- 3: [ ] After 4 hours.
5749 * -X3- 4: [ ] After 24 hours.
5750 * -X3- 5: [ ] After one week.
5751 * -X3- ------------- End -------------
5754 channel_multiple_option(enum charOption option
, struct userNode
*user
, struct chanNode
*channel
, int argc
, char *argv
[], struct svccmd
*cmd
)
5756 struct chanData
*cData
= channel
->channel_info
;
5757 int count
= charOptions
[option
].count
, index
;
5761 index
= atoi(argv
[1]);
5763 if(!isdigit(argv
[1][0]) || (index
< 0) || (index
>= count
))
5765 reply("CSMSG_INVALID_NUMERIC", index
);
5766 /* Show possible values. */
5767 for(index
= 0; index
< count
; index
++)
5768 reply(charOptions
[option
].format_name
, index
, user_find_message(user
, charOptions
[option
].values
[index
].format_name
));
5772 cData
->chOpts
[option
] = charOptions
[option
].values
[index
].value
;
5776 /* Find current option value. */
5779 (index
< count
) && (cData
->chOpts
[option
] != charOptions
[option
].values
[index
].value
);
5783 /* Somehow, the option value is corrupt; reset it to the default. */
5784 cData
->chOpts
[option
] = charOptions
[option
].default_value
;
5789 reply(charOptions
[option
].format_name
, index
, user_find_message(user
, charOptions
[option
].values
[index
].format_name
));
5793 static MODCMD_FUNC(chan_opt_automode
)
5795 return channel_multiple_option(chAutomode
, CSFUNC_ARGS
);
5798 static MODCMD_FUNC(chan_opt_protect
)
5800 return channel_multiple_option(chProtect
, CSFUNC_ARGS
);
5803 static MODCMD_FUNC(chan_opt_toys
)
5805 return channel_multiple_option(chToys
, CSFUNC_ARGS
);
5808 static MODCMD_FUNC(chan_opt_ctcpreaction
)
5810 return channel_multiple_option(chCTCPReaction
, CSFUNC_ARGS
);
5813 static MODCMD_FUNC(chan_opt_bantimeout
)
5815 return channel_multiple_option(chBanTimeout
, CSFUNC_ARGS
);
5818 static MODCMD_FUNC(chan_opt_topicrefresh
)
5820 return channel_multiple_option(chTopicRefresh
, CSFUNC_ARGS
);
5823 static struct svccmd_list set_shows_list
;
5826 handle_svccmd_unbind(struct svccmd
*target
) {
5828 for(ii
=0; ii
<set_shows_list
.used
; ++ii
)
5829 if(target
== set_shows_list
.list
[ii
])
5830 set_shows_list
.used
= 0;
5833 static CHANSERV_FUNC(cmd_set
)
5835 struct svccmd
*subcmd
;
5839 /* Check if we need to (re-)initialize set_shows_list. */
5840 if(!set_shows_list
.used
)
5842 if(!set_shows_list
.size
)
5844 set_shows_list
.size
= chanserv_conf
.set_shows
->used
;
5845 set_shows_list
.list
= calloc(set_shows_list
.size
, sizeof(set_shows_list
.list
[0]));
5847 for(ii
= 0; ii
< chanserv_conf
.set_shows
->used
; ii
++)
5849 const char *name
= chanserv_conf
.set_shows
->list
[ii
];
5850 sprintf(buf
, "%s %s", argv
[0], name
);
5851 subcmd
= dict_find(cmd
->parent
->commands
, buf
, NULL
);
5854 log_module(CS_LOG
, LOG_ERROR
, "Unable to find set option \"%s\".", name
);
5857 svccmd_list_append(&set_shows_list
, subcmd
);
5863 reply("CSMSG_CHANNEL_OPTIONS", channel
->name
);
5865 for(ii
= 0; ii
< set_shows_list
.used
; ii
++)
5867 subcmd
= set_shows_list
.list
[ii
];
5868 subcmd
->command
->func(user
, channel
, 1, argv
+1, subcmd
);
5870 reply("CSMSG_CHANNEL_OPTIONS_END");
5874 sprintf(buf
, "%s %s", argv
[0], argv
[1]);
5875 subcmd
= dict_find(cmd
->parent
->commands
, buf
, NULL
);
5878 reply("CSMSG_INVALID_OPTION", argv
[1], argv
[0]);
5881 if((argc
> 2) && !check_user_level(channel
, user
, lvlSetters
, 1, 0))
5883 reply("CSMSG_NO_ACCESS");
5887 return subcmd
->command
->func(user
, channel
, argc
- 1, argv
+ 1, subcmd
);
5891 user_binary_option(char *name
, unsigned long mask
, struct userNode
*user
, struct chanNode
*channel
, int argc
, char *argv
[], struct svccmd
*cmd
)
5893 struct userData
*uData
;
5895 uData
= GetChannelAccess(channel
->channel_info
, user
->handle_info
);
5898 reply("CSMSG_NOT_USER", channel
->name
);
5904 /* Just show current option value. */
5906 else if(enabled_string(argv
[1]))
5908 uData
->flags
|= mask
;
5910 else if(disabled_string(argv
[1]))
5912 uData
->flags
&= ~mask
;
5916 reply("MSG_INVALID_BINARY", argv
[1]);
5920 reply(name
, user_find_message(user
, (uData
->flags
& mask
) ? "MSG_ON" : "MSG_OFF"));
5924 static MODCMD_FUNC(user_opt_autoop
)
5926 struct userData
*uData
;
5928 uData
= GetChannelAccess(channel
->channel_info
, user
->handle_info
);
5931 reply("CSMSG_NOT_USER", channel
->name
);
5934 if(uData
->access
< UL_OP
/*channel->channel_info->lvlOpts[lvlGiveOps]*/)
5935 return user_binary_option("CSMSG_USET_AUTOVOICE", USER_AUTO_OP
, CSFUNC_ARGS
);
5937 return user_binary_option("CSMSG_USET_AUTOOP", USER_AUTO_OP
, CSFUNC_ARGS
);
5938 /* TODO: add halfops error message? or is the op one generic enough? */
5941 static MODCMD_FUNC(user_opt_autoinvite
)
5943 return user_binary_option("CSMSG_USET_AUTOINVITE", USER_AUTO_INVITE
, CSFUNC_ARGS
);
5946 static MODCMD_FUNC(user_opt_info
)
5948 struct userData
*uData
;
5951 uData
= GetChannelAccess(channel
->channel_info
, user
->handle_info
);
5955 /* If they got past the command restrictions (which require access)
5956 * but fail this test, we have some fool with security override on.
5958 reply("CSMSG_NOT_USER", channel
->name
);
5965 infoline
= unsplit_string(argv
+ 1, argc
- 1, NULL
);
5966 if(strlen(infoline
) > chanserv_conf
.max_userinfo_length
)
5968 reply("CSMSG_INFOLINE_TOO_LONG", chanserv_conf
.max_userinfo_length
);
5971 bp
= strcspn(infoline
, "\001");
5974 reply("CSMSG_BAD_INFOLINE", infoline
[bp
]);
5979 if(infoline
[0] == '*' && infoline
[1] == 0)
5982 uData
->info
= strdup(infoline
);
5985 reply("CSMSG_USET_INFO", uData
->info
);
5987 reply("CSMSG_USET_INFO", user_find_message(user
, "MSG_NONE"));
5991 struct svccmd_list uset_shows_list
;
5993 static CHANSERV_FUNC(cmd_uset
)
5995 struct svccmd
*subcmd
;
5999 /* Check if we need to (re-)initialize uset_shows_list. */
6000 if(!uset_shows_list
.used
)
6004 "AutoOp", "AutoInvite", "Info"
6007 if(!uset_shows_list
.size
)
6009 uset_shows_list
.size
= ArrayLength(options
);
6010 uset_shows_list
.list
= calloc(uset_shows_list
.size
, sizeof(uset_shows_list
.list
[0]));
6012 for(ii
= 0; ii
< ArrayLength(options
); ii
++)
6014 const char *name
= options
[ii
];
6015 sprintf(buf
, "%s %s", argv
[0], name
);
6016 subcmd
= dict_find(cmd
->parent
->commands
, buf
, NULL
);
6019 log_module(CS_LOG
, LOG_ERROR
, "Unable to find uset option %s.", name
);
6022 svccmd_list_append(&uset_shows_list
, subcmd
);
6028 /* Do this so options are presented in a consistent order. */
6029 reply("CSMSG_USER_OPTIONS");
6030 for(ii
= 0; ii
< uset_shows_list
.used
; ii
++)
6031 uset_shows_list
.list
[ii
]->command
->func(user
, channel
, 1, argv
+1, uset_shows_list
.list
[ii
]);
6035 sprintf(buf
, "%s %s", argv
[0], argv
[1]);
6036 subcmd
= dict_find(cmd
->parent
->commands
, buf
, NULL
);
6039 reply("CSMSG_INVALID_OPTION", argv
[1], argv
[0]);
6043 return subcmd
->command
->func(user
, channel
, argc
- 1, argv
+ 1, subcmd
);
6046 static CHANSERV_FUNC(cmd_giveownership
)
6048 struct handle_info
*new_owner_hi
;
6049 struct userData
*new_owner
, *curr_user
;
6050 struct chanData
*cData
= channel
->channel_info
;
6051 struct do_not_register
*dnr
;
6053 unsigned short co_access
;
6054 char reason
[MAXLEN
];
6057 curr_user
= GetChannelAccess(cData
, user
->handle_info
);
6058 force
= IsHelping(user
) && (argc
> 2) && !irccasecmp(argv
[2], "force");
6059 if(!curr_user
|| (curr_user
->access
!= UL_OWNER
))
6061 struct userData
*owner
= NULL
;
6062 for(curr_user
= channel
->channel_info
->users
;
6064 curr_user
= curr_user
->next
)
6066 if(curr_user
->access
!= UL_OWNER
)
6070 reply("CSMSG_MULTIPLE_OWNERS", channel
->name
);
6077 else if (!force
&& (now
< (time_t)(cData
->ownerTransfer
+ chanserv_conf
.giveownership_period
)))
6079 char delay
[INTERVALLEN
];
6080 intervalString(delay
, cData
->ownerTransfer
+ chanserv_conf
.giveownership_period
- now
, user
->handle_info
);
6081 reply("CSMSG_TRANSFER_WAIT", delay
, channel
->name
);
6084 if(!(new_owner_hi
= modcmd_get_handle_info(user
, argv
[1])))
6086 if(new_owner_hi
== user
->handle_info
)
6088 reply("CSMSG_NO_TRANSFER_SELF");
6091 new_owner
= GetChannelAccess(cData
, new_owner_hi
);
6096 new_owner
= add_channel_user(cData
, new_owner_hi
, UL_COOWNER
, 0, NULL
);
6100 reply("CSMSG_NO_CHAN_USER", new_owner_hi
->handle
, channel
->name
);
6104 if((chanserv_get_owned_count(new_owner_hi
) >= chanserv_conf
.max_owned
) && !force
)
6106 reply("CSMSG_OWN_TOO_MANY", new_owner_hi
->handle
, chanserv_conf
.max_owned
);
6109 if((dnr
= chanserv_is_dnr(NULL
, new_owner_hi
)) && !force
) {
6110 if(!IsHelping(user
))
6111 reply("CSMSG_DNR_ACCOUNT", new_owner_hi
->handle
);
6113 chanserv_show_dnrs(user
, cmd
, NULL
, new_owner_hi
->handle
);
6116 if(new_owner
->access
>= UL_COOWNER
)
6117 co_access
= new_owner
->access
;
6119 co_access
= UL_COOWNER
;
6120 new_owner
->access
= UL_OWNER
;
6122 curr_user
->access
= co_access
;
6123 cData
->ownerTransfer
= now
;
6124 reply("CSMSG_OWNERSHIP_GIVEN", channel
->name
, new_owner_hi
->handle
);
6125 sprintf(reason
, "%s ownership transferred to %s by %s.", channel
->name
, new_owner_hi
->handle
, user
->handle_info
->handle
);
6126 global_message(MESSAGE_RECIPIENT_OPERS
| MESSAGE_RECIPIENT_HELPERS
, reason
);
6130 static CHANSERV_FUNC(cmd_suspend
)
6132 struct handle_info
*hi
;
6133 struct userData
*self
, *target
;
6136 if(!(hi
= modcmd_get_handle_info(user
, argv
[1]))) return 0;
6137 self
= GetChannelUser(channel
->channel_info
, user
->handle_info
);
6138 if(!(target
= GetTrueChannelAccess(channel
->channel_info
, hi
)))
6140 reply("CSMSG_NO_CHAN_USER", hi
->handle
, channel
->name
);
6143 if(target
->access
>= self
->access
)
6145 reply("MSG_USER_OUTRANKED", hi
->handle
);
6148 if(target
->flags
& USER_SUSPENDED
)
6150 reply("CSMSG_ALREADY_SUSPENDED", hi
->handle
);
6155 target
->present
= 0;
6158 target
->flags
|= USER_SUSPENDED
;
6159 reply("CSMSG_USER_SUSPENDED", hi
->handle
, channel
->name
);
6163 static CHANSERV_FUNC(cmd_unsuspend
)
6165 struct handle_info
*hi
;
6166 struct userData
*self
, *target
;
6169 if(!(hi
= modcmd_get_handle_info(user
, argv
[1]))) return 0;
6170 self
= GetChannelUser(channel
->channel_info
, user
->handle_info
);
6171 if(!(target
= GetTrueChannelAccess(channel
->channel_info
, hi
)))
6173 reply("CSMSG_NO_CHAN_USER", hi
->handle
, channel
->name
);
6176 if(target
->access
>= self
->access
)
6178 reply("MSG_USER_OUTRANKED", hi
->handle
);
6181 if(!(target
->flags
& USER_SUSPENDED
))
6183 reply("CSMSG_NOT_SUSPENDED", hi
->handle
);
6186 target
->flags
&= ~USER_SUSPENDED
;
6187 scan_user_presence(target
, NULL
);
6188 reply("CSMSG_USER_UNSUSPENDED", hi
->handle
, channel
->name
);
6192 static MODCMD_FUNC(cmd_deleteme
)
6194 struct handle_info
*hi
;
6195 struct userData
*target
;
6196 const char *confirm_string
;
6197 unsigned short access
;
6200 hi
= user
->handle_info
;
6201 if(!(target
= GetTrueChannelAccess(channel
->channel_info
, hi
)))
6203 reply("CSMSG_NO_CHAN_USER", hi
->handle
, channel
->name
);
6206 if(target
->access
== UL_OWNER
)
6208 reply("CSMSG_NO_OWNER_DELETEME", channel
->name
);
6211 confirm_string
= make_confirmation_string(target
);
6212 if((argc
< 2) || strcmp(argv
[1], confirm_string
))
6214 reply("CSMSG_CONFIRM_DELETEME", confirm_string
);
6217 access
= target
->access
;
6218 channel_name
= strdup(channel
->name
);
6219 del_channel_user(target
, 1);
6220 reply("CSMSG_DELETED_YOU", access
, channel_name
);
6226 chanserv_refresh_topics(UNUSED_ARG(void *data
))
6228 unsigned int refresh_num
= (now
- self
->link
) / chanserv_conf
.refresh_period
;
6229 struct chanData
*cData
;
6232 for(cData
= channelList
; cData
; cData
= cData
->next
)
6234 if(IsSuspended(cData
))
6236 opt
= cData
->chOpts
[chTopicRefresh
];
6239 if((refresh_num
- cData
->last_refresh
) < (unsigned int)(1 << (opt
- '1')))
6242 SetChannelTopic(cData
->channel
, chanserv
, cData
->topic
, 1);
6243 cData
->last_refresh
= refresh_num
;
6245 timeq_add(now
+ chanserv_conf
.refresh_period
, chanserv_refresh_topics
, NULL
);
6248 static CHANSERV_FUNC(cmd_unf
)
6252 char response
[MAXLEN
];
6253 const char *fmt
= user_find_message(user
, "CSMSG_UNF_RESPONSE");
6254 sprintf(response
, "\ 2%s\ 2: %s", user
->nick
, fmt
);
6255 irc_privmsg(cmd
->parent
->bot
, channel
->name
, response
);
6258 reply("CSMSG_UNF_RESPONSE");
6262 static CHANSERV_FUNC(cmd_ping
)
6266 char response
[MAXLEN
];
6267 const char *fmt
= user_find_message(user
, "CSMSG_PING_RESPONSE");
6268 sprintf(response
, "\ 2%s\ 2: %s", user
->nick
, fmt
);
6269 irc_privmsg(cmd
->parent
->bot
, channel
->name
, response
);
6272 reply("CSMSG_PING_RESPONSE");
6276 static CHANSERV_FUNC(cmd_wut
)
6280 char response
[MAXLEN
];
6281 const char *fmt
= user_find_message(user
, "CSMSG_WUT_RESPONSE");
6282 sprintf(response
, "\ 2%s\ 2: %s", user
->nick
, fmt
);
6283 irc_privmsg(cmd
->parent
->bot
, channel
->name
, response
);
6286 reply("CSMSG_WUT_RESPONSE");
6291 static CHANSERV_FUNC(cmd_8ball
)
6293 unsigned int i
, j
, accum
;
6298 for(i
=1; i
<argc
; i
++)
6299 for(j
=0; argv
[i
][j
]; j
++)
6300 accum
= (accum
<< 5) - accum
+ toupper(argv
[i
][j
]);
6301 resp
= chanserv_conf
.eightball
->list
[accum
% chanserv_conf
.eightball
->used
];
6304 char response
[MAXLEN
];
6305 sprintf(response
, "\ 2%s\ 2: %s", user
->nick
, resp
);
6306 irc_privmsg(cmd
->parent
->bot
, channel
->name
, response
);
6309 send_message_type(4, user
, cmd
->parent
->bot
, "%s", resp
);
6313 #else /* Use cool 8ball instead */
6315 void eightball(char *outcome
, int method
, unsigned int seed
)
6319 #define NUMOFCOLORS 18
6320 char ballcolors
[50][50] = {"blue", "red", "green", "yellow",
6321 "white", "black", "grey", "brown",
6322 "yellow", "pink", "purple", "orange", "teal", "burgandy",
6323 "fuchsia","turquoise","magenta", "cyan"};
6324 #define NUMOFLOCATIONS 50
6325 char balllocations
[50][55] = {
6326 "Locke's house", "Oregon", "California", "Indiana", "Canada",
6327 "Russia", "Japan", "Florida", "the Bahamas", "Hiroshima",
6328 "the Caribbean", "the Everglades", "your head", "your pants", "your school",
6329 "the Statue of Liberty", "Mt. Fugi", "your mother's house", "IRC", "OSU",
6330 "Locke's cat", "the closet", "the washroom", "the lake", "Spain",
6331 "the bathtub", "the toilet", "the sewer", "a horse", "Jupiter",
6332 "Uranus", "Pluto", "a dark place", "your undies", "your shirt",
6333 "your bra", "your hair", "your bed", "the couch", "the wall",
6334 "Reed", "here --> [X]", "your brain", "Italy", "the Netherlands",
6335 "Mars", "my hardware", "the bar", "Neverland Ranch", "Germany" };
6336 #define NUMOFPREPS 15
6337 char ballpreps
[50][50] = {
6338 "Near", "Somewhere near", "In", "In", "In",
6339 "In", "Hiding in", "Under", "Next to", "Over",
6340 "Crying in", "Right beside", "Nowhere near", "North of", "Trying to find"};
6341 #define NUMOFNUMS 34
6342 char ballnums
[50][50] = {
6343 "A hundred", "A thousand", "A few", "42",
6344 "About 1", "About 2", "About 3", "About 4", "About 5", "About 6", "About 7", "About 8", "About 9", "About 10",
6345 "1", "2", "3", "4", "5", "6", "7", "8", "9", "Ten",
6346 "1", "2", "3", "4", "5", "6", "7", "8", "9", "Ten",
6348 #define NUMOFMULTS 8
6349 char ballmults
[50][50] = { " million", " or so", " thousand", "", " or less", " or more", "", ""};
6352 * 0: normal (Not used in x3)
6359 if (method
== 1) /* A Color */
6363 answer
= (rand() % 12); /* Make sure this is the # of entries */
6366 case 0: strcpy(tmp
, "Very bright %s, I'd say.");
6368 case 1: strcpy(tmp
, "Sort of a light %s color.");
6370 case 2: strcpy(tmp
, "Dark and dreary %s.");
6372 case 3: strcpy(tmp
, "Quite a pale shade of %s.");
6374 case 4: strcpy(tmp
, "A gross kind of mucky %s.");
6376 case 5: strcpy(tmp
, "Brilliant whiteish %s.");
6378 case 6: case 7: case 8: case 9: strcpy(tmp
, "%s.");
6380 case 10: strcpy(tmp
, "Solid %s.");
6382 case 11: strcpy(tmp
, "Transparent %s.");
6384 default: strcpy(outcome
, "An invalid random number was generated.");
6387 sprintf(outcome
, tmp
, ballcolors
[rand() % NUMOFCOLORS
]);
6390 else if (method
== 2) /* Location */
6392 sprintf(outcome
, "%s %s.", ballpreps
[rand() % NUMOFPREPS
], balllocations
[rand() % NUMOFLOCATIONS
]);
6394 else if (method
== 3) /* Number of ___ */
6396 sprintf(outcome
, "%s%s.", ballnums
[rand() % NUMOFNUMS
], ballmults
[rand() % NUMOFMULTS
]);
6400 //Debug(DBGWARNING, "Error in 8ball.");
6405 static CHANSERV_FUNC(cmd_8ball
)
6407 char *word1
, *word2
, *word3
;
6408 static char eb
[MAXLEN
];
6409 unsigned int accum
, i
, j
;
6413 for(i
=1; i
<argc
; i
++)
6414 for(j
=0; argv
[i
][j
]; j
++)
6415 accum
= (accum
<< 5) - accum
+ toupper(argv
[i
][j
]);
6417 accum
+= time(NULL
)/3600;
6419 word2
= argc
>2?argv
[2]:"";
6420 word3
= argc
>3?argv
[3]:"";
6423 if((word2
) && strcasecmp(word1
, "what") == 0 && strcasecmp(word2
, "color") == 0)
6424 eightball(eb
, 1, accum
);
6425 else if((word3
) && strcasecmp(word1
, "what's") == 0 && strcasecmp(word2
, "the") == 0 && strcasecmp(word3
, "color") == 0)
6426 eightball(eb
, 1, accum
);
6427 else if((word3
) && strcasecmp(word1
, "whats") == 0 && strcasecmp(word2
, "the") == 0 && strcasecmp(word3
, "color") == 0)
6428 eightball(eb
, 1, accum
);
6429 /*** LOCATION *****/
6434 (strcasecmp(word1
, "where") == 0) &&
6435 (strcasecmp(word2
, "is") == 0)
6439 strcasecmp(word1
, "where's") == 0
6442 eightball(eb
, 2, accum
);
6444 else if((word2
) && strcasecmp(word1
, "how") == 0 && strcasecmp(word2
, "many") == 0)
6445 eightball(eb
, 3, accum
);
6449 /* Generic 8ball question.. so pull from x3.conf srvx style */
6452 resp
= chanserv_conf
.eightball
->list
[accum
% chanserv_conf
.eightball
->used
];
6455 char response
[MAXLEN
];
6456 sprintf(response
, "\002%s\002: %s", user
->nick
, resp
);
6457 irc_privmsg(cmd
->parent
->bot
, channel
->name
, response
);
6460 send_message_type(4, user
, cmd
->parent
->bot
, "%s", resp
);
6466 char response
[MAXLEN
];
6467 sprintf(response
, "\002%s\002: %s", user
->nick
, eb
);
6468 irc_privmsg(cmd
->parent
->bot
, channel
->name
, response
);
6471 send_message_type(4, user
, cmd
->parent
->bot
, "%s", eb
);
6476 static CHANSERV_FUNC(cmd_d
)
6478 unsigned long sides
, count
, modifier
, ii
, total
;
6479 char response
[MAXLEN
], *sep
;
6483 if((count
= strtoul(argv
[1], &sep
, 10)) < 1)
6493 else if(((sep
[0] == 'd') || (sep
[0] == 'D')) && isdigit(sep
[1])
6494 && (sides
= strtoul(sep
+1, &sep
, 10)) > 1)
6498 else if((sep
[0] == '-') && isdigit(sep
[1]))
6499 modifier
= strtoul(sep
, NULL
, 10);
6500 else if((sep
[0] == '+') && isdigit(sep
[1]))
6501 modifier
= strtoul(sep
+1, NULL
, 10);
6508 reply("CSMSG_BAD_DIE_FORMAT", argv
[1]);
6513 reply("CSMSG_BAD_DICE_COUNT", count
, 10);
6516 for(total
= ii
= 0; ii
< count
; ++ii
)
6517 total
+= (rand() % sides
) + 1;
6520 if((count
> 1) || modifier
)
6522 fmt
= user_find_message(user
, "CSMSG_DICE_ROLL");
6523 sprintf(response
, fmt
, total
, count
, sides
, modifier
);
6527 fmt
= user_find_message(user
, "CSMSG_DIE_ROLL");
6528 sprintf(response
, fmt
, total
, sides
);
6531 send_channel_message(channel
, cmd
->parent
->bot
, "$b%s$b: %s", user
->nick
, response
);
6533 send_message_type(4, user
, cmd
->parent
->bot
, "%s", response
);
6537 static CHANSERV_FUNC(cmd_huggle
)
6539 /* CTCP must be via PRIVMSG, never notice */
6541 send_target_message(1, channel
->name
, cmd
->parent
->bot
, "CSMSG_HUGGLES_HIM", user
->nick
);
6543 send_target_message(1, user
->nick
, cmd
->parent
->bot
, "CSMSG_HUGGLES_YOU");
6547 static CHANSERV_FUNC(cmd_calc
)
6549 char response
[MAXLEN
];
6552 do_math(response
, unsplit_string(argv
+ 1, argc
- 1, NULL
));
6555 send_channel_message(channel
, cmd
->parent
->bot
, "$b%s$b: %s", user
->nick
, response
);
6557 send_message_type(4, user
, cmd
->parent
->bot
, "%s", response
);
6562 chanserv_adjust_limit(void *data
)
6564 struct mod_chanmode change
;
6565 struct chanData
*cData
= data
;
6566 struct chanNode
*channel
= cData
->channel
;
6569 if(IsSuspended(cData
))
6572 cData
->limitAdjusted
= now
;
6573 limit
= channel
->members
.used
+ chanserv_conf
.adjust_threshold
+ 5;
6574 if(cData
->modes
.modes_set
& MODE_LIMIT
)
6576 if(limit
> cData
->modes
.new_limit
)
6577 limit
= cData
->modes
.new_limit
;
6578 else if(limit
== cData
->modes
.new_limit
)
6582 mod_chanmode_init(&change
);
6583 change
.modes_set
= MODE_LIMIT
;
6584 change
.new_limit
= limit
;
6585 mod_chanmode_announce(chanserv
, channel
, &change
);
6589 handle_new_channel(struct chanNode
*channel
)
6591 struct chanData
*cData
;
6593 if(!(cData
= channel
->channel_info
))
6596 if(cData
->modes
.modes_set
|| cData
->modes
.modes_clear
)
6597 mod_chanmode_announce(chanserv
, cData
->channel
, &cData
->modes
);
6599 if(self
->uplink
&& !self
->uplink
->burst
&& channel
->channel_info
->topic
)
6600 SetChannelTopic(channel
, chanserv
, channel
->channel_info
->topic
, 1);
6603 /* Welcome to my worst nightmare. Warning: Read (or modify)
6604 the code below at your own risk. */
6606 handle_join(struct modeNode
*mNode
)
6608 struct mod_chanmode change
;
6609 struct userNode
*user
= mNode
->user
;
6610 struct chanNode
*channel
= mNode
->channel
;
6611 struct chanData
*cData
;
6612 struct userData
*uData
= NULL
;
6613 struct banData
*bData
;
6614 struct handle_info
*handle
;
6615 unsigned int modes
= 0, info
= 0;
6618 if(IsLocal(user
) || !channel
->channel_info
|| IsSuspended(channel
->channel_info
))
6621 cData
= channel
->channel_info
;
6622 if(channel
->members
.used
> cData
->max
)
6623 cData
->max
= channel
->members
.used
;
6625 mod_chanmode_init(&change
);
6627 if(channel
->banlist
.used
< MAXBANS
)
6629 /* Not joining through a ban. */
6630 for(bData
= cData
->bans
;
6631 bData
&& !user_matches_glob(user
, bData
->mask
, 1);
6632 bData
= bData
->next
);
6636 char kick_reason
[MAXLEN
];
6637 sprintf(kick_reason
, "(%s) %s", bData
->owner
, bData
->reason
);
6639 bData
->triggered
= now
;
6640 if(bData
!= cData
->bans
)
6642 /* Shuffle the ban to the head of the list. */
6644 bData
->next
->prev
= bData
->prev
;
6646 bData
->prev
->next
= bData
->next
;
6649 bData
->next
= cData
->bans
;
6652 cData
->bans
->prev
= bData
;
6653 cData
->bans
= bData
;
6656 change
.args
[0].mode
= MODE_BAN
;
6657 change
.args
[0].u
.hostmask
= bData
->mask
;
6658 mod_chanmode_announce(chanserv
, channel
, &change
);
6659 KickChannelUser(user
, channel
, chanserv
, kick_reason
);
6664 /* ChanServ will not modify the limits in join-flooded channels.
6665 It will also skip DynLimit processing when the user (or srvx)
6666 is bursting in, because there are likely more incoming. */
6667 if((cData
->flags
& CHANNEL_DYNAMIC_LIMIT
)
6668 && !user
->uplink
->burst
6669 && !channel
->join_flooded
6670 && (channel
->limit
- channel
->members
.used
) < chanserv_conf
.adjust_threshold
)
6672 /* The user count has begun "bumping" into the channel limit,
6673 so set a timer to raise the limit a bit. Any previous
6674 timers are removed so three incoming users within the delay
6675 results in one limit change, not three. */
6677 timeq_del(0, chanserv_adjust_limit
, cData
, TIMEQ_IGNORE_WHEN
);
6678 timeq_add(now
+ chanserv_conf
.adjust_delay
, chanserv_adjust_limit
, cData
);
6681 /* Give automodes exept during join-floods */
6682 if(!channel
->join_flooded
)
6684 if(cData
->chOpts
[chAutomode
] == 'v')
6685 modes
|= MODE_VOICE
;
6686 else if(cData
->chOpts
[chAutomode
] == 'h')
6687 modes
|= MODE_HALFOP
;
6688 else if(cData
->chOpts
[chAutomode
] == 'o')
6689 modes
|= MODE_CHANOP
;
6692 greeting
= cData
->greeting
;
6693 if(user
->handle_info
)
6695 handle
= user
->handle_info
;
6697 if(IsHelper(user
) && !IsHelping(user
))
6700 for(ii
= 0; ii
< chanserv_conf
.support_channels
.used
; ++ii
)
6702 if(channel
== chanserv_conf
.support_channels
.list
[ii
])
6704 HANDLE_SET_FLAG(user
->handle_info
, HELPING
);
6710 uData
= GetTrueChannelAccess(cData
, handle
);
6711 if(uData
&& !IsUserSuspended(uData
))
6713 /* non users getting automodes are handled above. */
6714 if(IsUserAutoOp(uData
) && cData
->chOpts
[chAutomode
] != 'n')
6716 if(uData
->access
>= UL_OP
)
6717 modes
|= MODE_CHANOP
;
6718 else if(uData
->access
>= UL_HALFOP
)
6719 modes
|= MODE_HALFOP
;
6720 else if(uData
->access
>= UL_PEON
&& cData
->chOpts
[chAutomode
] != 'm')
6721 modes
|= MODE_VOICE
;
6723 if(uData
->access
>= UL_PRESENT
)
6724 cData
->visited
= now
;
6725 if(cData
->user_greeting
)
6726 greeting
= cData
->user_greeting
;
6728 && (uData
->access
>= cData
->lvlOpts
[lvlUserInfo
])
6729 && ((now
- uData
->seen
) >= chanserv_conf
.info_delay
)
6736 if(!user
->uplink
->burst
)
6740 /* -- I'd rather have ops get voice too, if automode is v. -Rubin
6741 if(modes & MODE_CHANOP) {
6742 modes &= ~MODE_HALFOP;
6743 modes &= ~MODE_VOICE;
6746 change
.args
[0].mode
= modes
;
6747 change
.args
[0].u
.member
= mNode
;
6748 mod_chanmode_announce(chanserv
, channel
, &change
);
6750 if(greeting
&& !user
->uplink
->burst
)
6751 send_message_type(4, user
, chanserv
, "(%s) %s", channel
->name
, greeting
);
6753 send_target_message(5, channel
->name
, chanserv
, "[%s] %s", user
->nick
, uData
->info
);
6759 handle_auth(struct userNode
*user
, UNUSED_ARG(struct handle_info
*old_handle
))
6761 struct mod_chanmode change
;
6762 struct userData
*channel
;
6763 unsigned int ii
, jj
;
6765 if(!user
->handle_info
)
6768 mod_chanmode_init(&change
);
6770 for(channel
= user
->handle_info
->channels
; channel
; channel
= channel
->u_next
)
6772 struct chanNode
*cn
;
6773 struct modeNode
*mn
;
6774 if(IsUserSuspended(channel
)
6775 || IsSuspended(channel
->channel
)
6776 || !(cn
= channel
->channel
->channel
))
6779 mn
= GetUserMode(cn
, user
);
6782 if(!IsUserSuspended(channel
)
6783 && IsUserAutoInvite(channel
)
6784 && (channel
->access
>= channel
->channel
->lvlOpts
[lvlInviteMe
])
6786 && !user
->uplink
->burst
)
6787 irc_invite(chanserv
, user
, cn
);
6791 if(channel
->access
>= UL_PRESENT
)
6792 channel
->channel
->visited
= now
;
6794 if(IsUserAutoOp(channel
))
6796 if(channel
->access
>= UL_OP
)
6797 change
.args
[0].mode
= MODE_CHANOP
;
6798 else if(channel
->access
>= UL_HALFOP
)
6799 change
.args
[0].mode
= MODE_HALFOP
;
6800 else if(channel
->access
>= UL_PEON
)
6801 change
.args
[0].mode
= MODE_VOICE
;
6803 change
.args
[0].mode
= 0;
6804 change
.args
[0].u
.member
= mn
;
6805 if(change
.args
[0].mode
)
6806 mod_chanmode_announce(chanserv
, cn
, &change
);
6809 channel
->seen
= now
;
6810 channel
->present
= 1;
6813 for(ii
= 0; ii
< user
->channels
.used
; ++ii
)
6815 struct chanNode
*channel
= user
->channels
.list
[ii
]->channel
;
6816 struct banData
*ban
;
6818 if((user
->channels
.list
[ii
]->modes
& (MODE_CHANOP
|MODE_HALFOP
|MODE_VOICE
))
6819 || !channel
->channel_info
6820 || IsSuspended(channel
->channel_info
))
6822 for(jj
= 0; jj
< channel
->banlist
.used
; ++jj
)
6823 if(user_matches_glob(user
, channel
->banlist
.list
[jj
]->ban
, 1))
6825 if(jj
< channel
->banlist
.used
)
6827 for(ban
= channel
->channel_info
->bans
; ban
; ban
= ban
->next
)
6829 char kick_reason
[MAXLEN
];
6830 if(!user_matches_glob(user
, ban
->mask
, 1))
6832 change
.args
[0].mode
= MODE_BAN
;
6833 change
.args
[0].u
.hostmask
= ban
->mask
;
6834 mod_chanmode_announce(chanserv
, channel
, &change
);
6835 sprintf(kick_reason
, "(%s) %s", ban
->owner
, ban
->reason
);
6836 KickChannelUser(user
, channel
, chanserv
, kick_reason
);
6837 ban
->triggered
= now
;
6842 if(IsSupportHelper(user
))
6844 for(ii
= 0; ii
< chanserv_conf
.support_channels
.used
; ++ii
)
6846 if(GetUserMode(chanserv_conf
.support_channels
.list
[ii
], user
))
6848 HANDLE_SET_FLAG(user
->handle_info
, HELPING
);
6856 handle_part(struct modeNode
*mn
, UNUSED_ARG(const char *reason
))
6858 struct chanData
*cData
;
6859 struct userData
*uData
;
6861 cData
= mn
->channel
->channel_info
;
6862 if(!cData
|| IsSuspended(cData
) || IsLocal(mn
->user
))
6865 if((cData
->flags
& CHANNEL_DYNAMIC_LIMIT
) && !mn
->channel
->join_flooded
)
6867 /* Allow for a bit of padding so that the limit doesn't
6868 track the user count exactly, which could get annoying. */
6869 if((mn
->channel
->limit
- mn
->channel
->members
.used
) > chanserv_conf
.adjust_threshold
+ 5)
6871 timeq_del(0, chanserv_adjust_limit
, cData
, TIMEQ_IGNORE_WHEN
);
6872 timeq_add(now
+ chanserv_conf
.adjust_delay
, chanserv_adjust_limit
, cData
);
6876 if((uData
= GetTrueChannelAccess(cData
, mn
->user
->handle_info
)))
6878 scan_user_presence(uData
, mn
->user
);
6882 if(IsHelping(mn
->user
) && IsSupportHelper(mn
->user
))
6884 unsigned int ii
, jj
;
6885 for(ii
= 0; ii
< chanserv_conf
.support_channels
.used
; ++ii
)
6887 for(jj
= 0; jj
< mn
->user
->channels
.used
; ++jj
)
6888 if(mn
->user
->channels
.list
[jj
]->channel
== chanserv_conf
.support_channels
.list
[ii
])
6890 if(jj
< mn
->user
->channels
.used
)
6893 if(ii
== chanserv_conf
.support_channels
.used
)
6894 HANDLE_CLEAR_FLAG(mn
->user
->handle_info
, HELPING
);
6899 handle_kick(struct userNode
*kicker
, struct userNode
*victim
, struct chanNode
*channel
)
6901 struct userData
*uData
;
6903 if(!channel
->channel_info
|| !kicker
|| IsService(kicker
)
6904 || (kicker
== victim
) || IsSuspended(channel
->channel_info
)
6905 || (kicker
->handle_info
&& kicker
->handle_info
== victim
->handle_info
))
6908 if(protect_user(victim
, kicker
, channel
->channel_info
))
6910 const char *reason
= user_find_message(kicker
, "CSMSG_USER_PROTECTED_KICK");
6911 KickChannelUser(kicker
, channel
, chanserv
, reason
);
6914 if((uData
= GetTrueChannelAccess(channel
->channel_info
, victim
->handle_info
)))
6919 handle_topic(struct userNode
*user
, struct chanNode
*channel
, const char *old_topic
)
6921 struct chanData
*cData
;
6923 if(!channel
->channel_info
|| !user
|| IsSuspended(channel
->channel_info
) || IsService(user
))
6926 cData
= channel
->channel_info
;
6927 if(bad_topic(channel
, user
, channel
->topic
))
6928 { /* User doesnt have privs to set topics. Undo it */
6929 send_message(user
, chanserv
, "CSMSG_TOPIC_LOCKED", channel
->name
);
6930 SetChannelTopic(channel
, chanserv
, old_topic
, 1);
6933 /* If there is a topic mask set, and the new topic doesnt match,
6934 * set the topic to mask + new_topic */
6935 if(cData
->topic_mask
&& !match_ircglob(channel
->topic
, cData
->topic_mask
))
6937 char new_topic
[TOPICLEN
+1];
6938 conform_topic(cData
->topic_mask
, channel
->topic
, new_topic
);
6941 SetChannelTopic(channel
, chanserv
, new_topic
, 1);
6942 /* and fall through to topicsnarf code below.. */
6944 else /* Topic couldnt fit into mask, was too long */
6946 SetChannelTopic(channel
, chanserv
, old_topic
, 1);
6947 send_message(user
, chanserv
, "CSMSG_TOPICMASK_CONFLICT1", channel
->name
, cData
->topic_mask
);
6948 send_message(user
, chanserv
, "CSMSG_TOPICMASK_CONFLICT2", TOPICLEN
);
6952 /* With topicsnarf, grab the topic and save it as the default topic. */
6953 if(check_user_level(channel
, user
, lvlTopicSnarf
, 0, 0))
6956 cData
->topic
= strdup(channel
->topic
);
6962 handle_mode(struct chanNode
*channel
, struct userNode
*user
, const struct mod_chanmode
*change
)
6964 struct mod_chanmode
*bounce
= NULL
;
6965 unsigned int bnc
, ii
;
6968 if(!channel
->channel_info
|| IsLocal(user
) || IsSuspended(channel
->channel_info
) || IsService(user
))
6971 if(!check_user_level(channel
, user
, lvlEnfModes
, 1, 0)
6972 && mode_lock_violated(&channel
->channel_info
->modes
, change
))
6974 char correct
[MAXLEN
];
6975 bounce
= mod_chanmode_dup(&channel
->channel_info
->modes
, change
->argc
+ 1);
6976 mod_chanmode_format(&channel
->channel_info
->modes
, correct
);
6977 send_message(user
, chanserv
, "CSMSG_MODE_LOCKED", correct
, channel
->name
);
6979 for(ii
= bnc
= 0; ii
< change
->argc
; ++ii
)
6981 if((change
->args
[ii
].mode
& (MODE_REMOVE
|MODE_CHANOP
)) == (MODE_REMOVE
|MODE_CHANOP
))
6983 const struct userNode
*victim
= change
->args
[ii
].u
.member
->user
;
6984 if(!protect_user(victim
, user
, channel
->channel_info
))
6987 bounce
= mod_chanmode_alloc(change
->argc
+ 1 - ii
);
6990 bounce
->args
[bnc
].mode
= MODE_REMOVE
| MODE_CHANOP
;
6991 bounce
->args
[bnc
].u
.member
= GetUserMode(channel
, user
);
6992 if(bounce
->args
[bnc
].u
.member
)
6996 bounce
->args
[bnc
].mode
= MODE_CHANOP
;
6997 bounce
->args
[bnc
].u
.member
= change
->args
[ii
].u
.member
;
6999 send_message(user
, chanserv
, "CSMSG_USER_PROTECTED", victim
->nick
);
7001 else if(change
->args
[ii
].mode
& MODE_CHANOP
)
7003 const struct userNode
*victim
= change
->args
[ii
].u
.member
->user
;
7004 if(IsService(victim
) || validate_op(user
, channel
, (struct userNode
*)victim
))
7007 bounce
= mod_chanmode_alloc(change
->argc
+ 1 - ii
);
7008 bounce
->args
[bnc
].mode
= MODE_REMOVE
| MODE_CHANOP
;
7009 bounce
->args
[bnc
].u
.member
= change
->args
[ii
].u
.member
;
7012 else if((change
->args
[ii
].mode
& (MODE_REMOVE
| MODE_BAN
)) == MODE_BAN
)
7014 const char *ban
= change
->args
[ii
].u
.hostmask
;
7015 if(!bad_channel_ban(channel
, user
, ban
, NULL
, NULL
))
7018 bounce
= mod_chanmode_alloc(change
->argc
+ 1 - ii
);
7019 bounce
->args
[bnc
].mode
= MODE_REMOVE
| MODE_BAN
;
7020 bounce
->args
[bnc
].u
.hostmask
= strdup(ban
);
7022 send_message(user
, chanserv
, "CSMSG_MASK_PROTECTED", ban
);
7027 if((bounce
->argc
= bnc
) || bounce
->modes_set
|| bounce
->modes_clear
)
7028 mod_chanmode_announce(chanserv
, channel
, bounce
);
7029 for(ii
= 0; ii
< change
->argc
; ++ii
)
7030 if(bounce
->args
[ii
].mode
== (MODE_REMOVE
| MODE_BAN
))
7031 free((char*)bounce
->args
[ii
].u
.hostmask
);
7032 mod_chanmode_free(bounce
);
7037 handle_nick_change(struct userNode
*user
, UNUSED_ARG(const char *old_nick
))
7039 struct chanNode
*channel
;
7040 struct banData
*bData
;
7041 struct mod_chanmode change
;
7042 unsigned int ii
, jj
;
7043 char kick_reason
[MAXLEN
];
7045 mod_chanmode_init(&change
);
7047 change
.args
[0].mode
= MODE_BAN
;
7048 for(ii
= 0; ii
< user
->channels
.used
; ++ii
)
7050 channel
= user
->channels
.list
[ii
]->channel
;
7051 /* Need not check for bans if they're opped or voiced. */
7052 /* TODO: does this make sense in automode v, h, and o? *
7053 * lets still enforce on voice people anyway, and see how that goes -Rubin */
7054 if(user
->channels
.list
[ii
]->modes
& (MODE_CHANOP
|MODE_HALFOP
/*|MODE_VOICE */))
7056 /* Need not check for bans unless channel registration is active. */
7057 if(!channel
->channel_info
|| IsSuspended(channel
->channel_info
))
7059 /* Look for a matching ban already on the channel. */
7060 for(jj
= 0; jj
< channel
->banlist
.used
; ++jj
)
7061 if(user_matches_glob(user
, channel
->banlist
.list
[jj
]->ban
, 1))
7063 /* Need not act if we found one. */
7064 if(jj
< channel
->banlist
.used
)
7066 /* Look for a matching ban in this channel. */
7067 for(bData
= channel
->channel_info
->bans
; bData
; bData
= bData
->next
)
7069 if(!user_matches_glob(user
, bData
->mask
, 1))
7071 change
.args
[0].u
.hostmask
= bData
->mask
;
7072 mod_chanmode_announce(chanserv
, channel
, &change
);
7073 sprintf(kick_reason
, "(%s) %s", bData
->owner
, bData
->reason
);
7074 KickChannelUser(user
, channel
, chanserv
, kick_reason
);
7075 bData
->triggered
= now
;
7076 break; /* we don't need to check any more bans in the channel */
7081 static void handle_rename(struct handle_info
*handle
, const char *old_handle
)
7083 struct do_not_register
*dnr
= dict_find(handle_dnrs
, old_handle
, NULL
);
7087 dict_remove2(handle_dnrs
, old_handle
, 1);
7088 safestrncpy(dnr
->chan_name
+ 1, handle
->handle
, sizeof(dnr
->chan_name
) - 1);
7089 dict_insert(handle_dnrs
, dnr
->chan_name
+ 1, dnr
);
7094 handle_unreg(UNUSED_ARG(struct userNode
*user
), struct handle_info
*handle
)
7096 struct userNode
*h_user
;
7098 if(handle
->channels
)
7100 for(h_user
= handle
->users
; h_user
; h_user
= h_user
->next_authed
)
7101 send_message(h_user
, chanserv
, "CSMSG_HANDLE_UNREGISTERED");
7103 while(handle
->channels
)
7104 del_channel_user(handle
->channels
, 1);
7109 handle_server_link(UNUSED_ARG(struct server
*server
))
7111 struct chanData
*cData
;
7113 for(cData
= channelList
; cData
; cData
= cData
->next
)
7115 if(!IsSuspended(cData
))
7116 cData
->may_opchan
= 1;
7117 if((cData
->flags
& CHANNEL_DYNAMIC_LIMIT
)
7118 && !cData
->channel
->join_flooded
7119 && ((cData
->channel
->limit
- cData
->channel
->members
.used
)
7120 < chanserv_conf
.adjust_threshold
))
7122 timeq_del(0, chanserv_adjust_limit
, cData
, TIMEQ_IGNORE_WHEN
);
7123 timeq_add(now
+ chanserv_conf
.adjust_delay
, chanserv_adjust_limit
, cData
);
7129 chanserv_conf_read(void)
7133 char mode_line
[MAXLEN
], *modes
[MAXNUMPARAMS
];
7134 struct mod_chanmode
*change
;
7135 struct string_list
*strlist
;
7136 struct chanNode
*chan
;
7139 if(!(conf_node
= conf_get_data(CHANSERV_CONF_NAME
, RECDB_OBJECT
)))
7141 log_module(CS_LOG
, LOG_ERROR
, "Invalid config node `%s'.", CHANSERV_CONF_NAME
);
7144 for(ii
= 0; ii
< chanserv_conf
.support_channels
.used
; ++ii
)
7145 UnlockChannel(chanserv_conf
.support_channels
.list
[ii
]);
7146 chanserv_conf
.support_channels
.used
= 0;
7147 if((strlist
= database_get_data(conf_node
, KEY_SUPPORT_CHANNEL
, RECDB_STRING_LIST
)))
7149 for(ii
= 0; ii
< strlist
->used
; ++ii
)
7151 const char *str2
= database_get_data(conf_node
, KEY_SUPPORT_CHANNEL_MODES
, RECDB_QSTRING
);
7154 chan
= AddChannel(strlist
->list
[ii
], now
, str2
, NULL
, NULL
);
7156 channelList_append(&chanserv_conf
.support_channels
, chan
);
7159 else if((str
= database_get_data(conf_node
, KEY_SUPPORT_CHANNEL
, RECDB_QSTRING
)))
7162 str2
= database_get_data(conf_node
, KEY_SUPPORT_CHANNEL_MODES
, RECDB_QSTRING
);
7165 chan
= AddChannel(str
, now
, str2
, NULL
, NULL
);
7167 channelList_append(&chanserv_conf
.support_channels
, chan
);
7169 str
= database_get_data(conf_node
, KEY_DB_BACKUP_FREQ
, RECDB_QSTRING
);
7170 chanserv_conf
.db_backup_frequency
= str
? ParseInterval(str
) : 7200;
7171 str
= database_get_data(conf_node
, KEY_INFO_DELAY
, RECDB_QSTRING
);
7172 chanserv_conf
.info_delay
= str
? ParseInterval(str
) : 180;
7173 str
= database_get_data(conf_node
, KEY_MAX_GREETLEN
, RECDB_QSTRING
);
7174 chanserv_conf
.greeting_length
= str
? atoi(str
) : 200;
7175 str
= database_get_data(conf_node
, KEY_ADJUST_THRESHOLD
, RECDB_QSTRING
);
7176 chanserv_conf
.adjust_threshold
= str
? atoi(str
) : 15;
7177 str
= database_get_data(conf_node
, KEY_ADJUST_DELAY
, RECDB_QSTRING
);
7178 chanserv_conf
.adjust_delay
= str
? ParseInterval(str
) : 30;
7179 str
= database_get_data(conf_node
, KEY_CHAN_EXPIRE_FREQ
, RECDB_QSTRING
);
7180 chanserv_conf
.channel_expire_frequency
= str
? ParseInterval(str
) : 86400;
7181 str
= database_get_data(conf_node
, KEY_BAN_TIMEOUT_FREQ
, RECDB_QSTRING
);
7182 chanserv_conf
.ban_timeout_frequency
= str
? ParseInterval(str
) : 600;
7183 str
= database_get_data(conf_node
, KEY_CHAN_EXPIRE_DELAY
, RECDB_QSTRING
);
7184 chanserv_conf
.channel_expire_delay
= str
? ParseInterval(str
) : 86400*30;
7185 str
= database_get_data(conf_node
, KEY_NODELETE_LEVEL
, RECDB_QSTRING
);
7186 chanserv_conf
.nodelete_level
= str
? atoi(str
) : 1;
7187 str
= database_get_data(conf_node
, KEY_MAX_CHAN_USERS
, RECDB_QSTRING
);
7188 chanserv_conf
.max_chan_users
= str
? atoi(str
) : 512;
7189 str
= database_get_data(conf_node
, KEY_MAX_CHAN_BANS
, RECDB_QSTRING
);
7190 chanserv_conf
.max_chan_bans
= str
? atoi(str
) : 512;
7191 str
= database_get_data(conf_node
, KEY_MAX_USERINFO_LENGTH
, RECDB_QSTRING
);
7192 chanserv_conf
.max_userinfo_length
= str
? atoi(str
) : 400;
7193 str
= database_get_data(conf_node
, KEY_NICK
, RECDB_QSTRING
);
7195 NickChange(chanserv
, str
, 0);
7196 str
= database_get_data(conf_node
, KEY_REFRESH_PERIOD
, RECDB_QSTRING
);
7197 chanserv_conf
.refresh_period
= str
? ParseInterval(str
) : 3*60*60;
7198 str
= database_get_data(conf_node
, KEY_GIVEOWNERSHIP_PERIOD
, RECDB_QSTRING
);
7199 chanserv_conf
.giveownership_period
= str
? ParseInterval(str
) : 0;
7200 str
= database_get_data(conf_node
, KEY_CTCP_SHORT_BAN_DURATION
, RECDB_QSTRING
);
7201 chanserv_conf
.ctcp_short_ban_duration
= str
? str
: "3m";
7202 str
= database_get_data(conf_node
, KEY_CTCP_LONG_BAN_DURATION
, RECDB_QSTRING
);
7203 chanserv_conf
.ctcp_long_ban_duration
= str
? str
: "1h";
7204 str
= database_get_data(conf_node
, KEY_MAX_OWNED
, RECDB_QSTRING
);
7205 chanserv_conf
.max_owned
= str
? atoi(str
) : 5;
7206 str
= database_get_data(conf_node
, KEY_IRC_OPERATOR_EPITHET
, RECDB_QSTRING
);
7207 chanserv_conf
.irc_operator_epithet
= str
? str
: "a megalomaniacal power hungry tyrant";
7208 str
= database_get_data(conf_node
, KEY_NETWORK_HELPER_EPITHET
, RECDB_QSTRING
);
7209 chanserv_conf
.network_helper_epithet
= str
? str
: "a wannabe tyrant";
7210 str
= database_get_data(conf_node
, KEY_SUPPORT_HELPER_EPITHET
, RECDB_QSTRING
);
7211 chanserv_conf
.support_helper_epithet
= str
? str
: "a wannabe tyrant";
7212 str
= database_get_data(conf_node
, "default_modes", RECDB_QSTRING
);
7215 safestrncpy(mode_line
, str
, sizeof(mode_line
));
7216 ii
= split_line(mode_line
, 0, ArrayLength(modes
), modes
);
7217 if((change
= mod_chanmode_parse(NULL
, modes
, ii
, MCP_KEY_FREE
)) && (change
->argc
< 2))
7219 chanserv_conf
.default_modes
= *change
;
7220 mod_chanmode_free(change
);
7222 free_string_list(chanserv_conf
.set_shows
);
7223 strlist
= database_get_data(conf_node
, "set_shows", RECDB_STRING_LIST
);
7225 strlist
= string_list_copy(strlist
);
7228 static const char *list
[] = {
7229 /* free form text */
7230 "DefaultTopic", "TopicMask", "Greeting", "UserGreeting", "Modes",
7231 /* options based on user level */
7232 "PubCmd", "InviteMe", "UserInfo","EnfOps",
7233 "EnfHalfOps", "EnfModes", "EnfTopic", "TopicSnarf", "Setters",
7234 /* multiple choice options */
7235 "AutoMode", "CtcpReaction", "Protect", "Toys", "TopicRefresh",
7236 /* binary options */
7237 "DynLimit", "NoDelete", "BanTimeout",
7242 strlist
= alloc_string_list(ArrayLength(list
)-1);
7243 for(ii
=0; list
[ii
]; ii
++)
7244 string_list_append(strlist
, strdup(list
[ii
]));
7246 chanserv_conf
.set_shows
= strlist
;
7247 /* We don't look things up now, in case the list refers to options
7248 * defined by modules initialized after this point. Just mark the
7249 * function list as invalid, so it will be initialized.
7251 set_shows_list
.used
= 0;
7252 free_string_list(chanserv_conf
.eightball
);
7253 strlist
= database_get_data(conf_node
, KEY_8BALL_RESPONSES
, RECDB_STRING_LIST
);
7256 strlist
= string_list_copy(strlist
);
7260 strlist
= alloc_string_list(4);
7261 string_list_append(strlist
, strdup("Yes."));
7262 string_list_append(strlist
, strdup("No."));
7263 string_list_append(strlist
, strdup("Maybe so."));
7265 chanserv_conf
.eightball
= strlist
;
7266 free_string_list(chanserv_conf
.old_ban_names
);
7267 strlist
= database_get_data(conf_node
, KEY_OLD_BAN_NAMES
, RECDB_STRING_LIST
);
7269 strlist
= string_list_copy(strlist
);
7271 strlist
= alloc_string_list(2);
7272 chanserv_conf
.old_ban_names
= strlist
;
7273 str
= database_get_data(conf_node
, "off_channel", RECDB_QSTRING
);
7274 off_channel
= str
? atoi(str
) : 0;
7278 chanserv_note_type_read(const char *key
, struct record_data
*rd
)
7281 struct note_type
*ntype
;
7284 if(!(obj
= GET_RECORD_OBJECT(rd
)))
7286 log_module(CS_LOG
, LOG_ERROR
, "Invalid note type %s.", key
);
7289 if(!(ntype
= chanserv_create_note_type(key
)))
7291 log_module(CS_LOG
, LOG_ERROR
, "Memory allocation failed for note %s.", key
);
7295 /* Figure out set access */
7296 if((str
= database_get_data(obj
, KEY_NOTE_OPSERV_ACCESS
, RECDB_QSTRING
)))
7298 ntype
->set_access_type
= NOTE_SET_PRIVILEGED
;
7299 ntype
->set_access
.min_opserv
= strtoul(str
, NULL
, 0);
7301 else if((str
= database_get_data(obj
, KEY_NOTE_CHANNEL_ACCESS
, RECDB_QSTRING
)))
7303 ntype
->set_access_type
= NOTE_SET_CHANNEL_ACCESS
;
7304 ntype
->set_access
.min_ulevel
= strtoul(str
, NULL
, 0);
7306 else if((str
= database_get_data(obj
, KEY_NOTE_SETTER_ACCESS
, RECDB_QSTRING
)))
7308 ntype
->set_access_type
= NOTE_SET_CHANNEL_SETTER
;
7312 log_module(CS_LOG
, LOG_ERROR
, "Could not find access type for note %s; defaulting to OpServ access level 0.", key
);
7313 ntype
->set_access_type
= NOTE_SET_PRIVILEGED
;
7314 ntype
->set_access
.min_opserv
= 0;
7317 /* Figure out visibility */
7318 if(!(str
= database_get_data(obj
, KEY_NOTE_VISIBILITY
, RECDB_QSTRING
)))
7319 ntype
->visible_type
= NOTE_VIS_PRIVILEGED
;
7320 else if(!irccasecmp(str
, KEY_NOTE_VIS_PRIVILEGED
))
7321 ntype
->visible_type
= NOTE_VIS_PRIVILEGED
;
7322 else if(!irccasecmp(str
, KEY_NOTE_VIS_CHANNEL_USERS
))
7323 ntype
->visible_type
= NOTE_VIS_CHANNEL_USERS
;
7324 else if(!irccasecmp(str
, KEY_NOTE_VIS_ALL
))
7325 ntype
->visible_type
= NOTE_VIS_ALL
;
7327 ntype
->visible_type
= NOTE_VIS_PRIVILEGED
;
7329 str
= database_get_data(obj
, KEY_NOTE_MAX_LENGTH
, RECDB_QSTRING
);
7330 ntype
->max_length
= str
? strtoul(str
, NULL
, 0) : 400;
7334 user_read_helper(const char *key
, struct record_data
*rd
, struct chanData
*chan
)
7336 struct handle_info
*handle
;
7337 struct userData
*uData
;
7338 char *seen
, *inf
, *flags
;
7340 unsigned short access
;
7342 if(rd
->type
!= RECDB_OBJECT
|| !dict_size(rd
->d
.object
))
7344 log_module(CS_LOG
, LOG_ERROR
, "Invalid user in %s.", chan
->channel
->name
);
7348 access
= atoi(database_get_data(rd
->d
.object
, KEY_LEVEL
, RECDB_QSTRING
));
7349 if(access
> UL_OWNER
)
7351 log_module(CS_LOG
, LOG_ERROR
, "Invalid access level for %s in %s.", key
, chan
->channel
->name
);
7355 inf
= database_get_data(rd
->d
.object
, KEY_INFO
, RECDB_QSTRING
);
7356 seen
= database_get_data(rd
->d
.object
, KEY_SEEN
, RECDB_QSTRING
);
7357 last_seen
= seen
? (signed)strtoul(seen
, NULL
, 0) : now
;
7358 flags
= database_get_data(rd
->d
.object
, KEY_FLAGS
, RECDB_QSTRING
);
7359 handle
= get_handle_info(key
);
7362 log_module(CS_LOG
, LOG_ERROR
, "Nonexistent account %s in %s.", key
, chan
->channel
->name
);
7366 uData
= add_channel_user(chan
, handle
, access
, last_seen
, inf
);
7367 uData
->flags
= flags
? strtoul(flags
, NULL
, 0) : 0;
7369 /* Upgrade: set autoop to the inverse of noautoop */
7370 if(chanserv_read_version
< 2)
7372 /* if noautoop is true, set autoop false, and vice versa */
7373 if(uData
->flags
& USER_NOAUTO_OP
)
7374 uData
->flags
= uData
->flags
& ~USER_AUTO_OP
;
7376 uData
->flags
= uData
->flags
| USER_AUTO_OP
;
7377 log_module(CS_LOG
, LOG_INFO
, "UPGRADE: to db version 2 from %u. Changing flag to %d for %s in %s.", chanserv_read_version
, uData
->flags
, key
, chan
->channel
->name
);
7383 ban_read_helper(const char *key
, struct record_data
*rd
, struct chanData
*chan
)
7385 struct banData
*bData
;
7386 char *set
, *triggered
, *s_duration
, *s_expires
, *reason
, *owner
;
7387 time_t set_time
, triggered_time
, expires_time
;
7389 if(rd
->type
!= RECDB_OBJECT
|| !dict_size(rd
->d
.object
))
7391 log_module(CS_LOG
, LOG_ERROR
, "Invalid ban in %s.", chan
->channel
->name
);
7395 set
= database_get_data(rd
->d
.object
, KEY_SET
, RECDB_QSTRING
);
7396 triggered
= database_get_data(rd
->d
.object
, KEY_TRIGGERED
, RECDB_QSTRING
);
7397 s_duration
= database_get_data(rd
->d
.object
, KEY_DURATION
, RECDB_QSTRING
);
7398 s_expires
= database_get_data(rd
->d
.object
, KEY_EXPIRES
, RECDB_QSTRING
);
7399 owner
= database_get_data(rd
->d
.object
, KEY_OWNER
, RECDB_QSTRING
);
7400 reason
= database_get_data(rd
->d
.object
, KEY_REASON
, RECDB_QSTRING
);
7401 if (!reason
|| !owner
)
7404 set_time
= set
? (time_t)strtoul(set
, NULL
, 0) : now
;
7405 triggered_time
= triggered
? (time_t)strtoul(triggered
, NULL
, 0) : 0;
7407 expires_time
= (time_t)strtoul(s_expires
, NULL
, 0);
7409 expires_time
= set_time
+ atoi(s_duration
);
7413 if(!reason
|| (expires_time
&& (expires_time
< now
)))
7416 bData
= add_channel_ban(chan
, key
, owner
, set_time
, triggered_time
, expires_time
, reason
);
7419 static struct suspended
*
7420 chanserv_read_suspended(dict_t obj
)
7422 struct suspended
*suspended
= calloc(1, sizeof(*suspended
));
7426 str
= database_get_data(obj
, KEY_EXPIRES
, RECDB_QSTRING
);
7427 suspended
->expires
= str
? (time_t)strtoul(str
, NULL
, 0) : 0;
7428 str
= database_get_data(obj
, KEY_REVOKED
, RECDB_QSTRING
);
7429 suspended
->revoked
= str
? (time_t)strtoul(str
, NULL
, 0) : 0;
7430 str
= database_get_data(obj
, KEY_ISSUED
, RECDB_QSTRING
);
7431 suspended
->issued
= str
? (time_t)strtoul(str
, NULL
, 0) : 0;
7432 suspended
->suspender
= strdup(database_get_data(obj
, KEY_SUSPENDER
, RECDB_QSTRING
));
7433 suspended
->reason
= strdup(database_get_data(obj
, KEY_REASON
, RECDB_QSTRING
));
7434 previous
= database_get_data(obj
, KEY_PREVIOUS
, RECDB_OBJECT
);
7435 suspended
->previous
= previous
? chanserv_read_suspended(previous
) : NULL
;
7440 chanserv_channel_read(const char *key
, struct record_data
*hir
)
7442 struct suspended
*suspended
;
7443 struct mod_chanmode
*modes
;
7444 struct chanNode
*cNode
;
7445 struct chanData
*cData
;
7446 struct dict
*channel
, *obj
;
7447 char *str
, *argv
[10];
7451 channel
= hir
->d
.object
;
7453 str
= database_get_data(channel
, KEY_REGISTRAR
, RECDB_QSTRING
);
7456 cNode
= AddChannel(key
, now
, NULL
, NULL
, NULL
);
7459 log_module(CS_LOG
, LOG_ERROR
, "Unable to create registered channel %s.", key
);
7462 cData
= register_channel(cNode
, str
);
7465 log_module(CS_LOG
, LOG_ERROR
, "Unable to register channel %s from database.", key
);
7469 if((obj
= database_get_data(channel
, KEY_OPTIONS
, RECDB_OBJECT
)))
7471 enum levelOption lvlOpt
;
7472 enum charOption chOpt
;
7474 if((str
= database_get_data(obj
, KEY_FLAGS
, RECDB_QSTRING
)))
7475 cData
->flags
= atoi(str
);
7477 for(lvlOpt
= 0; lvlOpt
< NUM_LEVEL_OPTIONS
; ++lvlOpt
)
7479 str
= database_get_data(obj
, levelOptions
[lvlOpt
].db_name
, RECDB_QSTRING
);
7481 cData
->lvlOpts
[lvlOpt
] = user_level_from_name(str
, UL_OWNER
+1);
7482 else if(levelOptions
[lvlOpt
].old_flag
)
7484 if(cData
->flags
& levelOptions
[lvlOpt
].old_flag
)
7485 cData
->lvlOpts
[lvlOpt
] = levelOptions
[lvlOpt
].flag_value
;
7487 cData
->lvlOpts
[lvlOpt
] = levelOptions
[lvlOpt
].default_value
;
7491 for(chOpt
= 0; chOpt
< NUM_CHAR_OPTIONS
; ++chOpt
)
7493 if(!(str
= database_get_data(obj
, charOptions
[chOpt
].db_name
, RECDB_QSTRING
)))
7495 cData
->chOpts
[chOpt
] = str
[0];
7498 else if((str
= database_get_data(channel
, KEY_FLAGS
, RECDB_QSTRING
)))
7500 enum levelOption lvlOpt
;
7501 enum charOption chOpt
;
7504 cData
->flags
= base64toint(str
, 5);
7505 count
= strlen(str
+= 5);
7506 for(lvlOpt
= 0; lvlOpt
< NUM_LEVEL_OPTIONS
; ++lvlOpt
)
7509 if(levelOptions
[lvlOpt
].old_flag
)
7511 if(cData
->flags
& levelOptions
[lvlOpt
].old_flag
)
7512 lvl
= levelOptions
[lvlOpt
].flag_value
;
7514 lvl
= levelOptions
[lvlOpt
].default_value
;
7516 else switch(((count
<= levelOptions
[lvlOpt
].old_idx
) ? str
: CHANNEL_DEFAULT_OPTIONS
)[levelOptions
[lvlOpt
].old_idx
])
7518 case 'c': lvl
= UL_COOWNER
; break;
7519 case 'm': lvl
= UL_MANAGER
; break;
7520 case 'n': lvl
= UL_OWNER
+1; break;
7521 case 'o': lvl
= UL_OP
; break;
7522 case 'p': lvl
= UL_PEON
; break;
7523 case 'h': lvl
= UL_HALFOP
; break;
7524 case 'w': lvl
= UL_OWNER
; break;
7525 default: lvl
= 0; break;
7527 cData
->lvlOpts
[lvlOpt
] = lvl
;
7529 for(chOpt
= 0; chOpt
< NUM_CHAR_OPTIONS
; ++chOpt
)
7530 cData
->chOpts
[chOpt
] = ((count
<= charOptions
[chOpt
].old_idx
) ? str
: CHANNEL_DEFAULT_OPTIONS
)[charOptions
[chOpt
].old_idx
];
7533 if((obj
= database_get_data(hir
->d
.object
, KEY_SUSPENDED
, RECDB_OBJECT
)))
7535 suspended
= chanserv_read_suspended(obj
);
7536 cData
->suspended
= suspended
;
7537 suspended
->cData
= cData
;
7538 /* We could use suspended->expires and suspended->revoked to
7539 * set the CHANNEL_SUSPENDED flag, but we don't. */
7541 else if(IsSuspended(cData
) && (str
= database_get_data(hir
->d
.object
, KEY_SUSPENDER
, RECDB_QSTRING
)))
7543 suspended
= calloc(1, sizeof(*suspended
));
7544 suspended
->issued
= 0;
7545 suspended
->revoked
= 0;
7546 suspended
->suspender
= strdup(str
);
7547 str
= database_get_data(hir
->d
.object
, KEY_SUSPEND_EXPIRES
, RECDB_QSTRING
);
7548 suspended
->expires
= str
? atoi(str
) : 0;
7549 str
= database_get_data(hir
->d
.object
, KEY_SUSPEND_REASON
, RECDB_QSTRING
);
7550 suspended
->reason
= strdup(str
? str
: "No reason");
7551 suspended
->previous
= NULL
;
7552 cData
->suspended
= suspended
;
7553 suspended
->cData
= cData
;
7557 cData
->flags
&= ~CHANNEL_SUSPENDED
;
7558 suspended
= NULL
; /* to squelch a warning */
7561 if(IsSuspended(cData
)) {
7562 if(suspended
->expires
> now
)
7563 timeq_add(suspended
->expires
, chanserv_expire_suspension
, suspended
);
7564 else if(suspended
->expires
)
7565 cData
->flags
&= ~CHANNEL_SUSPENDED
;
7568 if((!off_channel
|| !IsOffChannel(cData
)) && !IsSuspended(cData
)) {
7569 struct mod_chanmode change
;
7570 mod_chanmode_init(&change
);
7572 change
.args
[0].mode
= MODE_CHANOP
;
7573 change
.args
[0].u
.member
= AddChannelUser(chanserv
, cNode
);
7574 mod_chanmode_announce(chanserv
, cNode
, &change
);
7577 str
= database_get_data(channel
, KEY_REGISTERED
, RECDB_QSTRING
);
7578 cData
->registered
= str
? (time_t)strtoul(str
, NULL
, 0) : now
;
7579 str
= database_get_data(channel
, KEY_VISITED
, RECDB_QSTRING
);
7580 cData
->visited
= str
? (time_t)strtoul(str
, NULL
, 0) : now
;
7581 str
= database_get_data(channel
, KEY_OWNER_TRANSFER
, RECDB_QSTRING
);
7582 cData
->ownerTransfer
= str
? (time_t)strtoul(str
, NULL
, 0) : 0;
7583 str
= database_get_data(channel
, KEY_MAX
, RECDB_QSTRING
);
7584 cData
->max
= str
? atoi(str
) : 0;
7585 str
= database_get_data(channel
, KEY_GREETING
, RECDB_QSTRING
);
7586 cData
->greeting
= str
? strdup(str
) : NULL
;
7587 str
= database_get_data(channel
, KEY_USER_GREETING
, RECDB_QSTRING
);
7588 cData
->user_greeting
= str
? strdup(str
) : NULL
;
7589 str
= database_get_data(channel
, KEY_TOPIC_MASK
, RECDB_QSTRING
);
7590 cData
->topic_mask
= str
? strdup(str
) : NULL
;
7591 str
= database_get_data(channel
, KEY_TOPIC
, RECDB_QSTRING
);
7592 cData
->topic
= str
? strdup(str
) : NULL
;
7594 if(!IsSuspended(cData
)
7595 && (str
= database_get_data(channel
, KEY_MODES
, RECDB_QSTRING
))
7596 && (argc
= split_line(str
, 0, ArrayLength(argv
), argv
))
7597 && (modes
= mod_chanmode_parse(cNode
, argv
, argc
, MCP_KEY_FREE
))) {
7598 cData
->modes
= *modes
;
7600 cData
->modes
.modes_set
|= MODE_REGISTERED
;
7601 if(cData
->modes
.argc
> 1)
7602 cData
->modes
.argc
= 1;
7603 mod_chanmode_announce(chanserv
, cNode
, &cData
->modes
);
7604 mod_chanmode_free(modes
);
7607 obj
= database_get_data(channel
, KEY_USERS
, RECDB_OBJECT
);
7608 for(it
= dict_first(obj
); it
; it
= iter_next(it
))
7609 user_read_helper(iter_key(it
), iter_data(it
), cData
);
7611 if(!cData
->users
&& !IsProtected(cData
))
7613 log_module(CS_LOG
, LOG_ERROR
, "Channel %s had no users in database, unregistering it.", key
);
7614 unregister_channel(cData
, "has empty user list.");
7618 obj
= database_get_data(channel
, KEY_BANS
, RECDB_OBJECT
);
7619 for(it
= dict_first(obj
); it
; it
= iter_next(it
))
7620 ban_read_helper(iter_key(it
), iter_data(it
), cData
);
7622 obj
= database_get_data(channel
, KEY_NOTES
, RECDB_OBJECT
);
7623 for(it
= dict_first(obj
); it
; it
= iter_next(it
))
7625 struct note_type
*ntype
= dict_find(note_types
, iter_key(it
), NULL
);
7626 struct record_data
*rd
= iter_data(it
);
7627 const char *note
, *setter
;
7629 if(rd
->type
!= RECDB_OBJECT
)
7631 log_module(CS_LOG
, LOG_ERROR
, "Bad record type for note %s in channel %s.", iter_key(it
), key
);
7635 log_module(CS_LOG
, LOG_ERROR
, "Bad note type name %s in channel %s.", iter_key(it
), key
);
7637 else if(!(note
= database_get_data(rd
->d
.object
, KEY_NOTE_NOTE
, RECDB_QSTRING
)))
7639 log_module(CS_LOG
, LOG_ERROR
, "Missing note text for note %s in channel %s.", iter_key(it
), key
);
7643 setter
= database_get_data(rd
->d
.object
, KEY_NOTE_SETTER
, RECDB_QSTRING
);
7644 if(!setter
) setter
= "<unknown>";
7645 chanserv_add_channel_note(cData
, ntype
, setter
, note
);
7653 chanserv_dnr_read(const char *key
, struct record_data
*hir
)
7655 const char *setter
, *reason
, *str
;
7656 struct do_not_register
*dnr
;
7658 setter
= database_get_data(hir
->d
.object
, KEY_DNR_SETTER
, RECDB_QSTRING
);
7661 log_module(CS_LOG
, LOG_ERROR
, "Missing setter for DNR %s.", key
);
7664 reason
= database_get_data(hir
->d
.object
, KEY_DNR_REASON
, RECDB_QSTRING
);
7667 log_module(CS_LOG
, LOG_ERROR
, "Missing reason for DNR %s.", key
);
7670 dnr
= chanserv_add_dnr(key
, setter
, reason
);
7673 str
= database_get_data(hir
->d
.object
, KEY_DNR_SET
, RECDB_QSTRING
);
7675 dnr
->set
= atoi(str
);
7681 chanserv_version_read(struct dict
*section
)
7685 str
= database_get_data(section
, KEY_VERSION_NUMBER
, RECDB_QSTRING
);
7687 chanserv_read_version
= atoi(str
);
7688 log_module(CS_LOG
, LOG_DEBUG
, "Chanserv db version is %d.", chanserv_read_version
);
7692 chanserv_saxdb_read(struct dict
*database
)
7694 struct dict
*section
;
7697 if((section
= database_get_data(database
, KEY_VERSION_CONTROL
, RECDB_OBJECT
)))
7698 chanserv_version_read(section
);
7700 if((section
= database_get_data(database
, KEY_NOTE_TYPES
, RECDB_OBJECT
)))
7701 for(it
= dict_first(section
); it
; it
= iter_next(it
))
7702 chanserv_note_type_read(iter_key(it
), iter_data(it
));
7704 if((section
= database_get_data(database
, KEY_CHANNELS
, RECDB_OBJECT
)))
7705 for(it
= dict_first(section
); it
; it
= iter_next(it
))
7706 chanserv_channel_read(iter_key(it
), iter_data(it
));
7708 if((section
= database_get_data(database
, KEY_DNR
, RECDB_OBJECT
)))
7709 for(it
= dict_first(section
); it
; it
= iter_next(it
))
7710 chanserv_dnr_read(iter_key(it
), iter_data(it
));
7716 chanserv_write_users(struct saxdb_context
*ctx
, struct userData
*uData
)
7718 int high_present
= 0;
7719 saxdb_start_record(ctx
, KEY_USERS
, 1);
7720 for(; uData
; uData
= uData
->next
)
7722 if((uData
->access
>= UL_PRESENT
) && uData
->present
)
7724 saxdb_start_record(ctx
, uData
->handle
->handle
, 0);
7725 saxdb_write_int(ctx
, KEY_LEVEL
, uData
->access
);
7726 saxdb_write_int(ctx
, KEY_SEEN
, uData
->seen
);
7728 saxdb_write_int(ctx
, KEY_FLAGS
, uData
->flags
);
7730 saxdb_write_string(ctx
, KEY_INFO
, uData
->info
);
7731 saxdb_end_record(ctx
);
7733 saxdb_end_record(ctx
);
7734 return high_present
;
7738 chanserv_write_bans(struct saxdb_context
*ctx
, struct banData
*bData
)
7742 saxdb_start_record(ctx
, KEY_BANS
, 1);
7743 for(; bData
; bData
= bData
->next
)
7745 saxdb_start_record(ctx
, bData
->mask
, 0);
7746 saxdb_write_int(ctx
, KEY_SET
, bData
->set
);
7747 if(bData
->triggered
)
7748 saxdb_write_int(ctx
, KEY_TRIGGERED
, bData
->triggered
);
7750 saxdb_write_int(ctx
, KEY_EXPIRES
, bData
->expires
);
7752 saxdb_write_string(ctx
, KEY_OWNER
, bData
->owner
);
7754 saxdb_write_string(ctx
, KEY_REASON
, bData
->reason
);
7755 saxdb_end_record(ctx
);
7757 saxdb_end_record(ctx
);
7761 chanserv_write_suspended(struct saxdb_context
*ctx
, const char *name
, struct suspended
*susp
)
7763 saxdb_start_record(ctx
, name
, 0);
7764 saxdb_write_string(ctx
, KEY_SUSPENDER
, susp
->suspender
);
7765 saxdb_write_string(ctx
, KEY_REASON
, susp
->reason
);
7767 saxdb_write_int(ctx
, KEY_ISSUED
, susp
->issued
);
7769 saxdb_write_int(ctx
, KEY_EXPIRES
, susp
->expires
);
7771 saxdb_write_int(ctx
, KEY_REVOKED
, susp
->revoked
);
7773 chanserv_write_suspended(ctx
, KEY_PREVIOUS
, susp
->previous
);
7774 saxdb_end_record(ctx
);
7778 chanserv_write_channel(struct saxdb_context
*ctx
, struct chanData
*channel
)
7782 enum levelOption lvlOpt
;
7783 enum charOption chOpt
;
7785 saxdb_start_record(ctx
, channel
->channel
->name
, 1);
7787 saxdb_write_int(ctx
, KEY_REGISTERED
, channel
->registered
);
7788 saxdb_write_int(ctx
, KEY_MAX
, channel
->max
);
7790 saxdb_write_string(ctx
, KEY_TOPIC
, channel
->topic
);
7791 if(channel
->registrar
)
7792 saxdb_write_string(ctx
, KEY_REGISTRAR
, channel
->registrar
);
7793 if(channel
->greeting
)
7794 saxdb_write_string(ctx
, KEY_GREETING
, channel
->greeting
);
7795 if(channel
->user_greeting
)
7796 saxdb_write_string(ctx
, KEY_USER_GREETING
, channel
->user_greeting
);
7797 if(channel
->topic_mask
)
7798 saxdb_write_string(ctx
, KEY_TOPIC_MASK
, channel
->topic_mask
);
7799 if(channel
->suspended
)
7800 chanserv_write_suspended(ctx
, "suspended", channel
->suspended
);
7802 saxdb_start_record(ctx
, KEY_OPTIONS
, 0);
7803 saxdb_write_int(ctx
, KEY_FLAGS
, channel
->flags
);
7804 for(lvlOpt
= 0; lvlOpt
< NUM_LEVEL_OPTIONS
; ++lvlOpt
)
7805 saxdb_write_int(ctx
, levelOptions
[lvlOpt
].db_name
, channel
->lvlOpts
[lvlOpt
]);
7806 for(chOpt
= 0; chOpt
< NUM_CHAR_OPTIONS
; ++chOpt
)
7808 buf
[0] = channel
->chOpts
[chOpt
];
7810 saxdb_write_string(ctx
, charOptions
[chOpt
].db_name
, buf
);
7812 saxdb_end_record(ctx
);
7814 if(channel
->modes
.modes_set
|| channel
->modes
.modes_clear
)
7816 mod_chanmode_format(&channel
->modes
, buf
);
7817 saxdb_write_string(ctx
, KEY_MODES
, buf
);
7820 high_present
= chanserv_write_users(ctx
, channel
->users
);
7821 chanserv_write_bans(ctx
, channel
->bans
);
7823 if(dict_size(channel
->notes
))
7827 saxdb_start_record(ctx
, KEY_NOTES
, 1);
7828 for(it
= dict_first(channel
->notes
); it
; it
= iter_next(it
))
7830 struct note
*note
= iter_data(it
);
7831 saxdb_start_record(ctx
, iter_key(it
), 0);
7832 saxdb_write_string(ctx
, KEY_NOTE_SETTER
, note
->setter
);
7833 saxdb_write_string(ctx
, KEY_NOTE_NOTE
, note
->note
);
7834 saxdb_end_record(ctx
);
7836 saxdb_end_record(ctx
);
7839 if(channel
->ownerTransfer
)
7840 saxdb_write_int(ctx
, KEY_OWNER_TRANSFER
, channel
->ownerTransfer
);
7841 saxdb_write_int(ctx
, KEY_VISITED
, high_present
? now
: channel
->visited
);
7842 saxdb_end_record(ctx
);
7846 chanserv_write_note_type(struct saxdb_context
*ctx
, struct note_type
*ntype
)
7850 saxdb_start_record(ctx
, ntype
->name
, 0);
7851 switch(ntype
->set_access_type
)
7853 case NOTE_SET_CHANNEL_ACCESS
:
7854 saxdb_write_int(ctx
, KEY_NOTE_CHANNEL_ACCESS
, ntype
->set_access
.min_ulevel
);
7856 case NOTE_SET_CHANNEL_SETTER
:
7857 saxdb_write_int(ctx
, KEY_NOTE_SETTER_ACCESS
, 1);
7859 case NOTE_SET_PRIVILEGED
: default:
7860 saxdb_write_int(ctx
, KEY_NOTE_OPSERV_ACCESS
, ntype
->set_access
.min_opserv
);
7863 switch(ntype
->visible_type
)
7865 case NOTE_VIS_ALL
: str
= KEY_NOTE_VIS_ALL
; break;
7866 case NOTE_VIS_CHANNEL_USERS
: str
= KEY_NOTE_VIS_CHANNEL_USERS
; break;
7867 case NOTE_VIS_PRIVILEGED
: default: str
= KEY_NOTE_VIS_PRIVILEGED
; break;
7869 saxdb_write_string(ctx
, KEY_NOTE_VISIBILITY
, str
);
7870 saxdb_write_int(ctx
, KEY_NOTE_MAX_LENGTH
, ntype
->max_length
);
7871 saxdb_end_record(ctx
);
7875 write_dnrs_helper(struct saxdb_context
*ctx
, struct dict
*dnrs
)
7877 struct do_not_register
*dnr
;
7880 for(it
= dict_first(dnrs
); it
; it
= iter_next(it
))
7882 dnr
= iter_data(it
);
7883 saxdb_start_record(ctx
, dnr
->chan_name
, 0);
7885 saxdb_write_int(ctx
, KEY_DNR_SET
, dnr
->set
);
7886 saxdb_write_string(ctx
, KEY_DNR_SETTER
, dnr
->setter
);
7887 saxdb_write_string(ctx
, KEY_DNR_REASON
, dnr
->reason
);
7888 saxdb_end_record(ctx
);
7893 chanserv_saxdb_write(struct saxdb_context
*ctx
)
7896 struct chanData
*channel
;
7898 /* Version Control*/
7899 saxdb_start_record(ctx
, KEY_VERSION_CONTROL
, 1);
7900 saxdb_write_int(ctx
, KEY_VERSION_NUMBER
, CHANSERV_DB_VERSION
);
7901 saxdb_end_record(ctx
);
7904 saxdb_start_record(ctx
, KEY_NOTE_TYPES
, 1);
7905 for(it
= dict_first(note_types
); it
; it
= iter_next(it
))
7906 chanserv_write_note_type(ctx
, iter_data(it
));
7907 saxdb_end_record(ctx
);
7910 saxdb_start_record(ctx
, KEY_DNR
, 1);
7911 write_dnrs_helper(ctx
, handle_dnrs
);
7912 write_dnrs_helper(ctx
, plain_dnrs
);
7913 write_dnrs_helper(ctx
, mask_dnrs
);
7914 saxdb_end_record(ctx
);
7917 saxdb_start_record(ctx
, KEY_CHANNELS
, 1);
7918 for(channel
= channelList
; channel
; channel
= channel
->next
)
7919 chanserv_write_channel(ctx
, channel
);
7920 saxdb_end_record(ctx
);
7926 chanserv_db_cleanup(void) {
7928 unreg_part_func(handle_part
);
7930 unregister_channel(channelList
, "terminating.");
7931 for(ii
= 0; ii
< chanserv_conf
.support_channels
.used
; ++ii
)
7932 UnlockChannel(chanserv_conf
.support_channels
.list
[ii
]);
7933 free(chanserv_conf
.support_channels
.list
);
7934 dict_delete(handle_dnrs
);
7935 dict_delete(plain_dnrs
);
7936 dict_delete(mask_dnrs
);
7937 dict_delete(note_types
);
7938 free_string_list(chanserv_conf
.eightball
);
7939 free_string_list(chanserv_conf
.old_ban_names
);
7940 free_string_list(chanserv_conf
.set_shows
);
7941 free(set_shows_list
.list
);
7942 free(uset_shows_list
.list
);
7945 struct userData
*helper
= helperList
;
7946 helperList
= helperList
->next
;
7951 #define DEFINE_COMMAND(NAME, MIN_ARGC, FLAGS, OPTIONS...) modcmd_register(chanserv_module, #NAME, cmd_##NAME, MIN_ARGC, FLAGS, ## OPTIONS)
7952 #define DEFINE_CHANNEL_OPTION(NAME) modcmd_register(chanserv_module, "set "#NAME, chan_opt_##NAME, 1, 0, NULL)
7953 #define DEFINE_USER_OPTION(NAME) modcmd_register(chanserv_module, "uset "#NAME, user_opt_##NAME, 1, MODCMD_REQUIRE_REGCHAN, NULL)
7956 init_chanserv(const char *nick
)
7958 CS_LOG
= log_register_type("ChanServ", "file:chanserv.log");
7959 conf_register_reload(chanserv_conf_read
);
7961 reg_server_link_func(handle_server_link
);
7963 reg_new_channel_func(handle_new_channel
);
7964 reg_join_func(handle_join
);
7965 reg_part_func(handle_part
);
7966 reg_kick_func(handle_kick
);
7967 reg_topic_func(handle_topic
);
7968 reg_mode_change_func(handle_mode
);
7969 reg_nick_change_func(handle_nick_change
);
7971 reg_auth_func(handle_auth
);
7972 reg_handle_rename_func(handle_rename
);
7973 reg_unreg_func(handle_unreg
);
7975 handle_dnrs
= dict_new();
7976 dict_set_free_data(handle_dnrs
, free
);
7977 plain_dnrs
= dict_new();
7978 dict_set_free_data(plain_dnrs
, free
);
7979 mask_dnrs
= dict_new();
7980 dict_set_free_data(mask_dnrs
, free
);
7982 reg_svccmd_unbind_func(handle_svccmd_unbind
);
7983 chanserv_module
= module_register("ChanServ", CS_LOG
, "chanserv.help", chanserv_expand_variable
);
7984 DEFINE_COMMAND(register, 1, MODCMD_REQUIRE_AUTHED
, "flags", "+acceptchan,+helping", NULL
);
7985 DEFINE_COMMAND(noregister
, 1, MODCMD_REQUIRE_AUTHED
, "flags", "+helping", NULL
);
7986 DEFINE_COMMAND(allowregister
, 2, 0, "template", "noregister", NULL
);
7987 DEFINE_COMMAND(move
, 1, MODCMD_REQUIRE_AUTHED
|MODCMD_REQUIRE_REGCHAN
, "template", "register", NULL
);
7988 DEFINE_COMMAND(csuspend
, 2, MODCMD_REQUIRE_AUTHED
|MODCMD_REQUIRE_REGCHAN
, "flags", "+helping", NULL
);
7989 DEFINE_COMMAND(cunsuspend
, 1, MODCMD_REQUIRE_AUTHED
|MODCMD_REQUIRE_REGCHAN
, "flags", "+helping", NULL
);
7990 DEFINE_COMMAND(createnote
, 5, 0, "level", "800", NULL
);
7991 DEFINE_COMMAND(removenote
, 2, 0, "level", "800", NULL
);
7993 DEFINE_COMMAND(pending
, 1, MODCMD_REQUIRE_AUTHED
, "flags", "+helping", NULL
);
7995 DEFINE_COMMAND(unregister
, 1, MODCMD_REQUIRE_AUTHED
|MODCMD_REQUIRE_REGCHAN
, "flags", "+loghostmask", NULL
);
7996 DEFINE_COMMAND(merge
, 2, MODCMD_REQUIRE_AUTHED
|MODCMD_REQUIRE_REGCHAN
, "access", "owner", NULL
);
7998 DEFINE_COMMAND(adduser
, 3, MODCMD_REQUIRE_CHANUSER
, "access", "manager", NULL
);
7999 DEFINE_COMMAND(deluser
, 2, MODCMD_REQUIRE_CHANUSER
, "access", "manager", NULL
);
8000 DEFINE_COMMAND(suspend
, 2, MODCMD_REQUIRE_CHANUSER
, "access", "manager", NULL
);
8001 DEFINE_COMMAND(unsuspend
, 2, MODCMD_REQUIRE_CHANUSER
, "access", "manager", NULL
);
8002 DEFINE_COMMAND(deleteme
, 1, MODCMD_REQUIRE_CHANUSER
, NULL
);
8004 DEFINE_COMMAND(mdelowner
, 2, MODCMD_REQUIRE_CHANUSER
, "flags", "+helping", NULL
);
8005 DEFINE_COMMAND(mdelcoowner
, 2, MODCMD_REQUIRE_CHANUSER
, "access", "owner", NULL
);
8006 DEFINE_COMMAND(mdelmanager
, 2, MODCMD_REQUIRE_CHANUSER
, "access", "coowner", NULL
);
8007 DEFINE_COMMAND(mdelop
, 2, MODCMD_REQUIRE_CHANUSER
, "access", "manager", NULL
);
8008 DEFINE_COMMAND(mdelpeon
, 2, MODCMD_REQUIRE_CHANUSER
, "access", "manager", NULL
);
8009 DEFINE_COMMAND(mdelhalfop
, 2, MODCMD_REQUIRE_CHANUSER
, "access", "manager", NULL
);
8011 DEFINE_COMMAND(trim
, 3, MODCMD_REQUIRE_CHANUSER
, "access", "manager", NULL
);
8012 DEFINE_COMMAND(opchan
, 1, MODCMD_REQUIRE_REGCHAN
|MODCMD_NEVER_CSUSPEND
, "access", "1", NULL
);
8013 DEFINE_COMMAND(clvl
, 3, MODCMD_REQUIRE_CHANUSER
, "access", "manager", NULL
);
8014 DEFINE_COMMAND(giveownership
, 2, MODCMD_REQUIRE_CHANUSER
, "access", "owner", "flags", "+loghostmask", NULL
);
8016 DEFINE_COMMAND(up
, 1, MODCMD_REQUIRE_CHANUSER
, NULL
);
8017 DEFINE_COMMAND(down
, 1, MODCMD_REQUIRE_REGCHAN
, NULL
);
8018 DEFINE_COMMAND(upall
, 1, MODCMD_REQUIRE_AUTHED
, NULL
);
8019 DEFINE_COMMAND(downall
, 1, MODCMD_REQUIRE_AUTHED
, NULL
);
8020 DEFINE_COMMAND(hop
, 2, MODCMD_REQUIRE_CHANNEL
, "access", "op", NULL
);
8021 DEFINE_COMMAND(op
, 2, MODCMD_REQUIRE_CHANNEL
, "access", "op", NULL
);
8022 DEFINE_COMMAND(deop
, 2, MODCMD_REQUIRE_CHANNEL
, "template", "op", NULL
);
8023 DEFINE_COMMAND(dehop
, 2, MODCMD_REQUIRE_CHANNEL
, "template", "op", NULL
);
8024 DEFINE_COMMAND(voice
, 2, MODCMD_REQUIRE_CHANNEL
, "template", "op", NULL
);
8025 DEFINE_COMMAND(devoice
, 2, MODCMD_REQUIRE_CHANNEL
, "template", "op", NULL
);
8027 DEFINE_COMMAND(kickban
, 2, MODCMD_REQUIRE_REGCHAN
, "template", "hop", NULL
);
8028 DEFINE_COMMAND(kick
, 2, MODCMD_REQUIRE_REGCHAN
, "template", "hop", NULL
);
8029 DEFINE_COMMAND(ban
, 2, MODCMD_REQUIRE_REGCHAN
, "template", "hop", NULL
);
8030 DEFINE_COMMAND(unban
, 2, 0, "template", "hop", NULL
);
8031 DEFINE_COMMAND(unbanall
, 1, 0, "template", "hop", NULL
);
8032 DEFINE_COMMAND(unbanme
, 1, MODCMD_REQUIRE_CHANUSER
, "template", "hop", NULL
);
8033 DEFINE_COMMAND(open
, 1, MODCMD_REQUIRE_CHANUSER
, "template", "op", NULL
);
8034 DEFINE_COMMAND(topic
, 1, MODCMD_REQUIRE_REGCHAN
, "template", "hop", "flags", "+never_csuspend", NULL
);
8035 DEFINE_COMMAND(mode
, 1, MODCMD_REQUIRE_REGCHAN
, "template", "op", NULL
);
8036 DEFINE_COMMAND(inviteme
, 1, MODCMD_REQUIRE_CHANNEL
, "access", "1", NULL
);
8037 DEFINE_COMMAND(invite
, 1, MODCMD_REQUIRE_CHANNEL
, "access", "manager", NULL
);
8038 DEFINE_COMMAND(set
, 1, MODCMD_REQUIRE_CHANUSER
, "access", "op", NULL
);
8039 DEFINE_COMMAND(wipeinfo
, 2, MODCMD_REQUIRE_CHANUSER
, "access", "manager", NULL
);
8040 DEFINE_COMMAND(resync
, 1, MODCMD_REQUIRE_CHANUSER
, "access", "manager", NULL
);
8042 DEFINE_COMMAND(events
, 1, MODCMD_REQUIRE_REGCHAN
, "flags", "+nolog", "access", "manager", NULL
);
8043 DEFINE_COMMAND(last
, 1, MODCMD_REQUIRE_REGCHAN
, "flags", "+nolog", "access", "manager", NULL
);
8044 DEFINE_COMMAND(addlamer
, 2, MODCMD_REQUIRE_REGCHAN
, "access", "manager", NULL
);
8045 DEFINE_COMMAND(addtimedlamer
, 3, MODCMD_REQUIRE_REGCHAN
, "access", "manager", NULL
);
8047 /* if you change dellamer access, see also places
8048 * like unbanme which have manager hardcoded. */
8049 DEFINE_COMMAND(dellamer
, 2, MODCMD_REQUIRE_REGCHAN
, "access", "manager", NULL
);
8050 DEFINE_COMMAND(uset
, 1, MODCMD_REQUIRE_CHANUSER
, "access", "1", NULL
);
8052 DEFINE_COMMAND(lamers
, 1, MODCMD_REQUIRE_REGCHAN
, "access", "1", "flags", "+nolog", NULL
);
8054 DEFINE_COMMAND(peek
, 1, MODCMD_REQUIRE_REGCHAN
, "access", "op", "flags", "+nolog", NULL
);
8056 DEFINE_COMMAND(myaccess
, 1, MODCMD_REQUIRE_AUTHED
, NULL
);
8057 DEFINE_COMMAND(access
, 1, MODCMD_REQUIRE_REGCHAN
, "flags", "+nolog,+joinable", NULL
);
8058 DEFINE_COMMAND(users
, 1, MODCMD_REQUIRE_REGCHAN
, "flags", "+nolog,+joinable", NULL
);
8059 DEFINE_COMMAND(wlist
, 1, MODCMD_REQUIRE_REGCHAN
, "flags", "+nolog,+joinable", NULL
);
8060 DEFINE_COMMAND(clist
, 1, MODCMD_REQUIRE_REGCHAN
, "flags", "+nolog,+joinable", NULL
);
8061 DEFINE_COMMAND(mlist
, 1, MODCMD_REQUIRE_REGCHAN
, "flags", "+nolog,+joinable", NULL
);
8062 DEFINE_COMMAND(olist
, 1, MODCMD_REQUIRE_REGCHAN
, "flags", "+nolog,+joinable", NULL
);
8063 DEFINE_COMMAND(hlist
, 1, MODCMD_REQUIRE_REGCHAN
, "flags", "+nolog,+joinable", NULL
);
8064 DEFINE_COMMAND(plist
, 1, MODCMD_REQUIRE_REGCHAN
, "flags", "+nolog,+joinable", NULL
);
8065 DEFINE_COMMAND(info
, 1, MODCMD_REQUIRE_REGCHAN
, "flags", "+nolog,+joinable", NULL
);
8066 DEFINE_COMMAND(seen
, 2, MODCMD_REQUIRE_REGCHAN
, "flags", "+nolog,+joinable", NULL
);
8067 DEFINE_COMMAND(names
, 1, MODCMD_REQUIRE_REGCHAN
, "flags", "+nolog,+joinable", NULL
);
8069 DEFINE_COMMAND(note
, 1, MODCMD_REQUIRE_REGCHAN
, "flags", "+joinable,+acceptchan", NULL
);
8070 DEFINE_COMMAND(delnote
, 2, MODCMD_REQUIRE_CHANUSER
, NULL
);
8072 DEFINE_COMMAND(netinfo
, 1, 0, "flags", "+nolog", NULL
);
8073 DEFINE_COMMAND(ircops
, 1, 0, "flags", "+nolog", NULL
);
8074 DEFINE_COMMAND(helpers
, 1, 0, "flags", "+nolog", NULL
);
8075 DEFINE_COMMAND(staff
, 1, 0, "flags", "+nolog", NULL
);
8077 DEFINE_COMMAND(say
, 2, 0, "flags", "+oper,+acceptchan", NULL
);
8078 DEFINE_COMMAND(emote
, 2, 0, "flags", "+oper,+acceptchan", NULL
);
8079 DEFINE_COMMAND(expire
, 1, 0, "flags", "+oper", NULL
);
8080 DEFINE_COMMAND(search
, 3, 0, "flags", "+nolog,+helping", NULL
);
8081 DEFINE_COMMAND(unvisited
, 1, 0, "flags", "+nolog,+helping", NULL
);
8083 DEFINE_COMMAND(unf
, 1, 0, "flags", "+nolog,+toy,+acceptchan", NULL
);
8084 DEFINE_COMMAND(ping
, 1, 0, "flags", "+nolog,+toy,+acceptchan", NULL
);
8085 DEFINE_COMMAND(wut
, 1, 0, "flags", "+nolog,+toy,+acceptchan", NULL
);
8086 DEFINE_COMMAND(8ball
, 1, 0, "flags", "+nolog,+toy,+acceptchan", NULL
);
8087 DEFINE_COMMAND(d
, 1, 0, "flags", "+nolog,+toy,+acceptchan", NULL
);
8088 DEFINE_COMMAND(huggle
, 1, 0, "flags", "+nolog,+toy,+acceptchan", NULL
);
8089 DEFINE_COMMAND(calc
, 1, 0, "flags", "+nolog,+toy,+acceptchan", NULL
);
8091 /* Channel options */
8092 DEFINE_CHANNEL_OPTION(defaulttopic
);
8093 DEFINE_CHANNEL_OPTION(topicmask
);
8094 DEFINE_CHANNEL_OPTION(greeting
);
8095 DEFINE_CHANNEL_OPTION(usergreeting
);
8096 DEFINE_CHANNEL_OPTION(modes
);
8097 DEFINE_CHANNEL_OPTION(enfops
);
8098 DEFINE_CHANNEL_OPTION(enfhalfops
);
8099 DEFINE_CHANNEL_OPTION(automode
);
8100 DEFINE_CHANNEL_OPTION(protect
);
8101 DEFINE_CHANNEL_OPTION(enfmodes
);
8102 DEFINE_CHANNEL_OPTION(enftopic
);
8103 DEFINE_CHANNEL_OPTION(pubcmd
);
8104 DEFINE_CHANNEL_OPTION(userinfo
);
8105 DEFINE_CHANNEL_OPTION(dynlimit
);
8106 DEFINE_CHANNEL_OPTION(topicsnarf
);
8107 DEFINE_CHANNEL_OPTION(nodelete
);
8108 DEFINE_CHANNEL_OPTION(toys
);
8109 DEFINE_CHANNEL_OPTION(setters
);
8110 DEFINE_CHANNEL_OPTION(topicrefresh
);
8111 DEFINE_CHANNEL_OPTION(ctcpreaction
);
8112 DEFINE_CHANNEL_OPTION(bantimeout
);
8113 DEFINE_CHANNEL_OPTION(inviteme
);
8115 DEFINE_CHANNEL_OPTION(offchannel
);
8116 modcmd_register(chanserv_module
, "set defaults", chan_opt_defaults
, 1, 0, "access", "owner", NULL
);
8118 /* Alias set topic to set defaulttopic for compatibility. */
8119 modcmd_register(chanserv_module
, "set topic", chan_opt_defaulttopic
, 1, 0, NULL
);
8122 DEFINE_USER_OPTION(autoinvite
);
8123 DEFINE_USER_OPTION(info
);
8124 DEFINE_USER_OPTION(autoop
);
8126 /* Alias uset autovoice to uset autoop. */
8127 modcmd_register(chanserv_module
, "uset autovoice", user_opt_autoop
, 1, 0, NULL
);
8129 note_types
= dict_new();
8130 dict_set_free_data(note_types
, chanserv_deref_note_type
);
8133 const char *modes
= conf_get_data("services/chanserv/modes", RECDB_QSTRING
);
8134 chanserv
= AddService(nick
, modes
? modes
: NULL
, "Channel Services", NULL
);
8135 service_register(chanserv
)->trigger
= '!';
8136 reg_chanmsg_func('\001', chanserv
, chanserv_ctcp_check
);
8139 saxdb_register("ChanServ", chanserv_saxdb_read
, chanserv_saxdb_write
);
8141 if(chanserv_conf
.channel_expire_frequency
)
8142 timeq_add(now
+ chanserv_conf
.channel_expire_frequency
, expire_channels
, NULL
);
8144 if(chanserv_conf
.ban_timeout_frequency
)
8145 timeq_add(now
+ chanserv_conf
.ban_timeout_frequency
, expire_bans
, NULL
);
8147 if(chanserv_conf
.refresh_period
)
8149 time_t next_refresh
;
8150 next_refresh
= (now
+ chanserv_conf
.refresh_period
- 1) / chanserv_conf
.refresh_period
* chanserv_conf
.refresh_period
;
8151 timeq_add(next_refresh
, chanserv_refresh_topics
, NULL
);
8154 reg_exit_func(chanserv_db_cleanup
);
8155 message_register_table(msgtab
);