Anope: src/core/cs_modes.c Source File

00001 /* ChanServ core functions
00002  *
00003  * (C) 2003-2007 Anope Team
00004  * Contact us at info@anope.org
00005  *
00006  * Please read COPYING and README for further details.
00007  *
00008  * Based on the original code of Epona by Lara.
00009  * Based on the original code of Services by Andy Church. 
00010  * 
00011  * $Id: cs_modes.c 1265 2007-08-26 15:33:06Z geniusdex $
00012  *
00013  */
00014 /*************************************************************************/
00015 
00016 #include "module.h"
00017 
00018 void myChanServHelp(User * u);
00019 int do_util(User * u, CSModeUtil * util);
00020 int do_op(User * u);
00021 int do_deop(User * u);
00022 int do_voice(User * u);
00023 int do_devoice(User * u);
00024 int do_halfop(User * u);
00025 int do_dehalfop(User * u);
00026 int do_protect(User * u);
00027 int do_deprotect(User * u);
00028 int do_owner(User * u);
00029 int do_deowner(User * u);
00030 
00037 int AnopeInit(int argc, char **argv)
00038 {
00039     Command *c;
00040 
00041     moduleAddAuthor("Anope");
00042     moduleAddVersion("$Id: cs_modes.c 1265 2007-08-26 15:33:06Z geniusdex $");
00043     moduleSetType(CORE);
00044 
00045     c = createCommand("OP", do_op, NULL, CHAN_HELP_OP, -1, -1, -1, -1);
00046     moduleAddCommand(CHANSERV, c, MOD_UNIQUE);
00047     c = createCommand("DEOP", do_deop, NULL, CHAN_HELP_DEOP, -1, -1, -1,
00048                       -1);
00049     moduleAddCommand(CHANSERV, c, MOD_UNIQUE);
00050     c = createCommand("VOICE", do_voice, NULL, CHAN_HELP_VOICE, -1, -1, -1,
00051                       -1);
00052     moduleAddCommand(CHANSERV, c, MOD_UNIQUE);
00053     c = createCommand("DEVOICE", do_devoice, NULL, CHAN_HELP_DEVOICE, -1,
00054                       -1, -1, -1);
00055     moduleAddCommand(CHANSERV, c, MOD_UNIQUE);
00056     if (ircd->halfop) {
00057         c = createCommand("HALFOP", do_halfop, NULL, CHAN_HELP_HALFOP, -1,
00058                           -1, -1, -1);
00059         moduleAddCommand(CHANSERV, c, MOD_UNIQUE);
00060         c = createCommand("DEHALFOP", do_dehalfop, NULL,
00061                           CHAN_HELP_DEHALFOP, -1, -1, -1, -1);
00062         moduleAddCommand(CHANSERV, c, MOD_UNIQUE);
00063     }
00064     if (ircd->protect) {
00065         c = createCommand("PROTECT", do_protect, NULL, CHAN_HELP_PROTECT,
00066                           -1, -1, -1, -1);
00067         moduleAddCommand(CHANSERV, c, MOD_UNIQUE);
00068         c = createCommand("DEPROTECT", do_deprotect, NULL,
00069                           CHAN_HELP_DEPROTECT, -1, -1, -1, -1);
00070         moduleAddCommand(CHANSERV, c, MOD_UNIQUE);
00071     }
00072     if (ircd->owner) {
00073         c = createCommand("OWNER", do_owner, NULL, CHAN_HELP_OWNER, -1, -1,
00074                           -1, -1);
00075         moduleAddCommand(CHANSERV, c, MOD_UNIQUE);
00076         c = createCommand("DEOWNER", do_deowner, NULL, CHAN_HELP_DEOWNER,
00077                           -1, -1, -1, -1);
00078         moduleAddCommand(CHANSERV, c, MOD_UNIQUE);
00079     }
00080     if (ircd->admin) {
00081         c = createCommand("ADMIN", do_protect, NULL, CHAN_HELP_PROTECT, -1,
00082                           -1, -1, -1);
00083         moduleAddCommand(CHANSERV, c, MOD_UNIQUE);
00084         c = createCommand("DEADMIN", do_deprotect, NULL,
00085                           CHAN_HELP_DEPROTECT, -1, -1, -1, -1);
00086         moduleAddCommand(CHANSERV, c, MOD_UNIQUE);
00087     }
00088 
00089     moduleSetChanHelp(myChanServHelp);
00090 
00091     return MOD_CONT;
00092 }
00093 
00097 void AnopeFini(void)
00098 {
00099 
00100 }
00101 
00106 void myChanServHelp(User * u)
00107 {
00108     if (ircd->owner) {
00109         notice_lang(s_ChanServ, u, CHAN_HELP_CMD_OWNER);
00110         notice_lang(s_ChanServ, u, CHAN_HELP_CMD_DEOWNER);
00111     }
00112     if (ircd->protect) {
00113         notice_lang(s_ChanServ, u, CHAN_HELP_CMD_PROTECT);
00114         notice_lang(s_ChanServ, u, CHAN_HELP_CMD_DEPROTECT);
00115     } else if (ircd->admin) {
00116         notice_lang(s_ChanServ, u, CHAN_HELP_CMD_ADMIN);
00117         notice_lang(s_ChanServ, u, CHAN_HELP_CMD_DEADMIN);
00118     }
00119 
00120     notice_lang(s_ChanServ, u, CHAN_HELP_CMD_OP);
00121     notice_lang(s_ChanServ, u, CHAN_HELP_CMD_DEOP);
00122     if (ircd->halfop) {
00123         notice_lang(s_ChanServ, u, CHAN_HELP_CMD_HALFOP);
00124         notice_lang(s_ChanServ, u, CHAN_HELP_CMD_DEHALFOP);
00125     }
00126     notice_lang(s_ChanServ, u, CHAN_HELP_CMD_VOICE);
00127     notice_lang(s_ChanServ, u, CHAN_HELP_CMD_DEVOICE);
00128 }
00129 
00136 int do_op(User * u)
00137 {
00138     return do_util(u, &csmodeutils[MUT_OP]);
00139 }
00140 
00141 /*************************************************************************/
00142 
00143 int do_deop(User * u)
00144 {
00145     return do_util(u, &csmodeutils[MUT_DEOP]);
00146 }
00147 
00148 /*************************************************************************/
00149 
00150 int do_voice(User * u)
00151 {
00152     return do_util(u, &csmodeutils[MUT_VOICE]);
00153 }
00154 
00155 /*************************************************************************/
00156 
00157 int do_devoice(User * u)
00158 {
00159     return do_util(u, &csmodeutils[MUT_DEVOICE]);
00160 }
00161 
00162 /*************************************************************************/
00163 
00164 int do_halfop(User * u)
00165 {
00166     if (ircd->halfop) {
00167         return do_util(u, &csmodeutils[MUT_HALFOP]);
00168     } else {
00169         return MOD_CONT;
00170     }
00171 }
00172 
00173 /*************************************************************************/
00174 
00175 int do_dehalfop(User * u)
00176 {
00177     if (ircd->halfop) {
00178         return do_util(u, &csmodeutils[MUT_DEHALFOP]);
00179     } else {
00180         return MOD_CONT;
00181     }
00182 }
00183 
00184 /*************************************************************************/
00185 
00186 int do_protect(User * u)
00187 {
00188     if (ircd->protect || ircd->admin) {
00189         return do_util(u, &csmodeutils[MUT_PROTECT]);
00190     } else {
00191         return MOD_CONT;
00192     }
00193 }
00194 
00195 /*************************************************************************/
00196 
00197 int do_deprotect(User * u)
00198 {
00199     if (ircd->protect || ircd->admin) {
00200         return do_util(u, &csmodeutils[MUT_DEPROTECT]);
00201     } else {
00202         return MOD_CONT;
00203     }
00204 }
00205 
00206 /*************************************************************************/
00207 
00208 int do_owner(User * u)
00209 {
00210     char *av[2];
00211     char *chan = strtok(NULL, " ");
00212 
00213     Channel *c;
00214     ChannelInfo *ci;
00215     struct u_chanlist *uc;
00216 
00217     if (!ircd->owner) {
00218         return MOD_CONT;
00219     }
00220 
00221     if (!chan) {
00222         av[0] = sstrdup(ircd->ownerset);
00223         av[1] = u->nick;
00224 
00225         /* Sets the mode to the user on every channels he is on. */
00226 
00227         for (uc = u->chans; uc; uc = uc->next) {
00228             if ((ci = uc->chan->ci) && !(ci->flags & CI_VERBOTEN)
00229                 && is_founder(u, ci)) {
00230                 anope_cmd_mode(whosends(ci), uc->chan->name, "%s %s",
00231                                av[0], u->nick);
00232                 chan_set_modes(s_ChanServ, uc->chan, 2, av, 1);
00233             }
00234         }
00235 
00236         free(av[0]);
00237         return MOD_CONT;
00238     }
00239 
00240     if (!(c = findchan(chan))) {
00241         notice_lang(s_ChanServ, u, CHAN_X_NOT_IN_USE, chan);
00242     } else if (!(ci = c->ci)) {
00243         notice_lang(s_ChanServ, u, CHAN_X_NOT_REGISTERED, c->name);
00244     } else if (ci->flags & CI_VERBOTEN) {
00245         notice_lang(s_ChanServ, u, CHAN_X_FORBIDDEN, ci->name);
00246     } else if (!is_on_chan(c, u)) {
00247         notice_lang(s_ChanServ, u, NICK_X_NOT_ON_CHAN, u->nick, c->name);
00248     } else if (!is_founder(u, ci)) {
00249         notice_lang(s_ChanServ, u, ACCESS_DENIED);
00250     } else {
00251         anope_cmd_mode(whosends(ci), c->name, "%s %s", ircd->ownerset,
00252                        u->nick);
00253 
00254         av[0] = sstrdup(ircd->ownerset);
00255         av[1] = u->nick;
00256         chan_set_modes(s_ChanServ, c, 2, av, 1);
00257         free(av[0]);
00258     }
00259     return MOD_CONT;
00260 }
00261 
00262 /*************************************************************************/
00263 
00264 int do_deowner(User * u)
00265 {
00266     char *av[2];
00267     char *chan = strtok(NULL, " ");
00268 
00269     Channel *c;
00270     ChannelInfo *ci;
00271     struct u_chanlist *uc;
00272 
00273     if (!ircd->owner) {
00274         return MOD_CONT;
00275     }
00276 
00277     if (!chan) {
00278         av[0] = sstrdup(ircd->ownerunset);
00279         av[1] = u->nick;
00280 
00281         /* Sets the mode to the user on every channels he is on. */
00282 
00283         for (uc = u->chans; uc; uc = uc->next) {
00284             if ((ci = uc->chan->ci) && !(ci->flags & CI_VERBOTEN)
00285                 && is_founder(u, ci)) {
00286                 anope_cmd_mode(whosends(ci), uc->chan->name, "%s %s",
00287                                av[0], u->nick);
00288                 chan_set_modes(s_ChanServ, uc->chan, 2, av, 1);
00289             }
00290         }
00291 
00292         free(av[0]);
00293         return MOD_CONT;
00294     }
00295 
00296     if (!(c = findchan(chan))) {
00297         notice_lang(s_ChanServ, u, CHAN_X_NOT_IN_USE, chan);
00298     } else if (!(ci = c->ci)) {
00299         notice_lang(s_ChanServ, u, CHAN_X_NOT_REGISTERED, c->name);
00300     } else if (ci->flags & CI_VERBOTEN) {
00301         notice_lang(s_ChanServ, u, CHAN_X_FORBIDDEN, ci->name);
00302     } else if (!is_on_chan(c, u)) {
00303         notice_lang(s_ChanServ, u, NICK_X_NOT_ON_CHAN, u->nick, c->name);
00304     } else if (!is_founder(u, ci)) {
00305         notice_lang(s_ChanServ, u, ACCESS_DENIED);
00306     } else {
00307         anope_cmd_mode(whosends(ci), c->name, "%s %s", ircd->ownerunset,
00308                        u->nick);
00309 
00310         av[0] = sstrdup(ircd->ownerunset);
00311         av[1] = u->nick;
00312         chan_set_modes(s_ChanServ, c, 2, av, 1);
00313         free(av[0]);
00314     }
00315     return MOD_CONT;
00316 }
00317 
00318 /* do_util: not a command, but does the job of other */
00319 
00320 int do_util(User * u, CSModeUtil * util)
00321 {
00322     char *av[2];
00323     char *chan = strtok(NULL, " ");
00324     char *nick = strtok(NULL, " ");
00325 
00326     Channel *c;
00327     ChannelInfo *ci;
00328     User *u2;
00329 
00330     int is_same;
00331 
00332     if (!chan) {
00333         struct u_chanlist *uc;
00334 
00335         av[0] = util->mode;
00336         av[1] = u->nick;
00337 
00338         /* Sets the mode to the user on every channels he is on. */
00339 
00340         for (uc = u->chans; uc; uc = uc->next) {
00341             if ((ci = uc->chan->ci) && !(ci->flags & CI_VERBOTEN)
00342                 && check_access(u, ci, util->levelself)) {
00343                 anope_cmd_mode(whosends(ci), uc->chan->name, "%s %s",
00344                                util->mode, u->nick);
00345                 chan_set_modes(s_ChanServ, uc->chan, 2, av, 1);
00346 
00347                 if (util->notice && ci->flags & util->notice)
00348                     notice(whosends(ci), uc->chan->name,
00349                            "%s command used for %s by %s", util->name,
00350                            u->nick, u->nick);
00351             }
00352         }
00353 
00354         return MOD_CONT;
00355     } else if (!nick) {
00356         nick = u->nick;
00357     }
00358 
00359     is_same = (nick == u->nick) ? 1 : (stricmp(nick, u->nick) == 0);
00360 
00361     if (!(c = findchan(chan))) {
00362         notice_lang(s_ChanServ, u, CHAN_X_NOT_IN_USE, chan);
00363     } else if (!(ci = c->ci)) {
00364         notice_lang(s_ChanServ, u, CHAN_X_NOT_REGISTERED, c->name);
00365     } else if (ci->flags & CI_VERBOTEN) {
00366         notice_lang(s_ChanServ, u, CHAN_X_FORBIDDEN, ci->name);
00367     } else if (is_same ? !(u2 = u) : !(u2 = finduser(nick))) {
00368         notice_lang(s_ChanServ, u, NICK_X_NOT_IN_USE, nick);
00369     } else if (!is_on_chan(c, u2)) {
00370         notice_lang(s_ChanServ, u, NICK_X_NOT_ON_CHAN, u2->nick, c->name);
00371     } else if (is_same ? !check_access(u, ci, util->levelself) :
00372                !check_access(u, ci, util->level)) {
00373         notice_lang(s_ChanServ, u, ACCESS_DENIED);
00374     } else if (*util->mode == '-' && !is_same && (ci->flags & CI_PEACE)
00375                && (get_access(u2, ci) >= get_access(u, ci))) {
00376         notice_lang(s_ChanServ, u, PERMISSION_DENIED);
00377     } else if (*util->mode == '-' && is_protected(u2) && !is_same) {
00378         notice_lang(s_ChanServ, u, PERMISSION_DENIED);
00379     } else {
00380         anope_cmd_mode(whosends(ci), c->name, "%s %s", util->mode,
00381                        u2->nick);
00382 
00383         av[0] = util->mode;
00384         av[1] = u2->nick;
00385         chan_set_modes(s_ChanServ, c, 2, av, 1);
00386 
00387         if (util->notice && ci->flags & util->notice)
00388             notice(whosends(ci), c->name, "%s command used for %s by %s",
00389                    util->name, u2->nick, u->nick);
00390     }
00391     return MOD_CONT;
00392 }