extensions/helpops.c

   1 /*
   2  * Helpops system.
   3  *   -- kaniini
   4  */
   5
   6 #include "stdinc.h"
   7 #include "modules.h"
   8 #include "client.h"
   9 #include "hook.h"
  10 #include "ircd.h"
  11 #include "send.h"
  12 #include "s_conf.h"
  13 #include "s_user.h"
  14 #include "s_newconf.h"
  15 #include "numeric.h"
  16
  17 static const char helpops_desc[] = "The helpops system as used by freenode";
  18
  19 static rb_dlink_list helper_list = { NULL, NULL, 0 };
  20 static void h_hdl_stats_request(void *hdata);
  21 static void h_hdl_new_remote_user(void *client_p);
  22 static void h_hdl_client_exit(void *hdata);
  23 static void h_hdl_umode_changed(void *hdata);
  24 static void h_hdl_whois(void *hdata);
  25 static void recurse_client_exit(struct Client *client_p);
  26 static void helper_add(struct Client *client_p);
  27 static void helper_delete(struct Client *client_p);
  28 static void mo_dehelper(struct MsgBuf *, struct Client *, struct Client *, int, const char **);
  29 static void me_dehelper(struct MsgBuf *, struct Client *, struct Client *, int, const char **);
  30 static void do_dehelper(struct Client *source_p, struct Client *target_p);
  31
  32 mapi_hfn_list_av1 helpops_hfnlist[] = {
  33         { "doing_stats", h_hdl_stats_request },
  34         { "new_remote_user", h_hdl_new_remote_user },
  35         { "client_exit", h_hdl_client_exit },
  36         { "umode_changed", h_hdl_umode_changed },
  37         { "doing_whois", h_hdl_whois },
  38         { "doing_whois_global", h_hdl_whois },
  39         { NULL, NULL }
  40 };
  41
  42 #define UMODECHAR_HELPOPS 'h'
  43
  44 struct Message dehelper_msgtab = {
  45         "DEHELPER", 0, 0, 0, 0,
  46         {mg_unreg, mg_not_oper, mg_not_oper, mg_ignore, {me_dehelper, 2}, {mo_dehelper, 2}}
  47 };
  48
  49 mapi_clist_av1 helpops_clist[] = { &dehelper_msgtab, NULL };
  50
  51 static void
  52 mo_dehelper(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source_p, int parc, const char **parv)
  53 {
  54         struct Client *target_p;
  55
  56         if (!HasPrivilege(source_p, "oper:dehelper"))
  57         {
  58                 sendto_one(source_p, form_str(ERR_NOPRIVS), me.name, source_p->name, "dehelper");
  59                 return;
  60         }
  61
  62         if(!(target_p = find_named_person(parv[1])))
  63         {
  64                 sendto_one_numeric(source_p, ERR_NOSUCHNICK, form_str(ERR_NOSUCHNICK), parv[1]);
  65                 return;
  66         }
  67
  68         if(MyClient(target_p))
  69                 do_dehelper(source_p, target_p);
  70         else
  71                 sendto_one(target_p, ":%s ENCAP %s DEHELPER %s",
  72                                 use_id(source_p), target_p->servptr->name, use_id(target_p));
  73 }
  74
  75 static void
  76 me_dehelper(struct MsgBuf *msgbuf_p, struct Client *client_p, struct Client *source_p, int parc, const char **parv)
  77 {
  78         struct Client *target_p = find_person(parv[1]);
  79         if(!target_p)
  80         {
  81                 sendto_one_numeric(source_p, ERR_NOSUCHNICK, form_str(ERR_NOSUCHNICK), parv[1]);
  82                 return;
  83         }
  84         if(!MyClient(target_p))
  85                 return;
  86
  87         do_dehelper(source_p, target_p);
  88 }
  89
  90 static void
  91 do_dehelper(struct Client *source_p, struct Client *target_p)
  92 {
  93         const char *fakeparv[4];
  94         static const char minus_helpops[3] = {'-', UMODECHAR_HELPOPS, '\0'};
  95
  96         if(!(target_p->umodes & user_modes[UMODECHAR_HELPOPS]))
  97                 return;
  98
  99         sendto_realops_snomask(SNO_GENERAL, L_NETWIDE, "%s is using DEHELPER on %s",
 100                         source_p->name, target_p->name);
 101         sendto_one_notice(target_p, ":*** %s is using DEHELPER on you", source_p->name);
 102
 103         fakeparv[0] = fakeparv[1] = target_p->name;
 104         fakeparv[2] = minus_helpops;
 105         fakeparv[3] = NULL;
 106         user_mode(target_p, target_p, 3, fakeparv);
 107 }
 108
 109 static int
 110 _modinit(void)
 111 {
 112         rb_dlink_node *ptr;
 113
 114         user_modes[UMODECHAR_HELPOPS] = find_umode_slot();
 115         construct_umodebuf();
 116
 117         RB_DLINK_FOREACH (ptr, global_client_list.head)
 118         {
 119                 struct Client *client_p = ptr->data;
 120                 if (IsPerson(client_p) && (client_p->umodes & user_modes[UMODECHAR_HELPOPS]))
 121                         helper_add(client_p);
 122         }
 123
 124         return 0;
 125 }
 126
 127 static void
 128 _moddeinit(void)
 129 {
 130         rb_dlink_node *n, *tn;
 131
 132         user_modes[UMODECHAR_HELPOPS] = 0;
 133         construct_umodebuf();
 134
 135         RB_DLINK_FOREACH_SAFE(n, tn, helper_list.head)
 136                 rb_dlinkDestroy(n, &helper_list);
 137 }
 138
 139 static void
 140 h_hdl_stats_request(void *data)
 141 {
 142         hook_data_int *hdata = data;
 143         struct Client *target_p;
 144         rb_dlink_node *helper_ptr;
 145         unsigned int count = 0;
 146
 147         if (hdata->arg2 != 'p')
 148                 return;
 149
 150         RB_DLINK_FOREACH (helper_ptr, helper_list.head)
 151         {
 152                 target_p = helper_ptr->data;
 153
 154                 if(target_p->user->away)
 155                         continue;
 156
 157                 count++;
 158
 159                 if (IsOper(hdata->client) && SeesOper(target_p, hdata->client)
 160                                 && !EmptyString(target_p->user->opername))
 161                         sendto_one_numeric(hdata->client, RPL_STATSDEBUG,
 162                                 "p :%s (%s@%s) {%s}",
 163                                 target_p->name, target_p->username, target_p->host,
 164                                 target_p->user->opername);
 165                 else
 166                         sendto_one_numeric(hdata->client, RPL_STATSDEBUG,
 167                                 "p :%s (%s@%s)",
 168                                 target_p->name, target_p->username, target_p->host);
 169         }
 170
 171         sendto_one_numeric(hdata->client, RPL_STATSDEBUG,
 172                 "p :%u staff members", count);
 173
 174         hdata->result = 1;
 175 }
 176
 177 static void
 178 helper_add(struct Client *client_p)
 179 {
 180         if (rb_dlinkFind(client_p, &helper_list) != NULL)
 181                 return;
 182
 183         rb_dlinkAddAlloc(client_p, &helper_list);
 184 }
 185
 186 static void
 187 helper_delete(struct Client *client_p)
 188 {
 189         rb_dlinkFindDestroy(client_p, &helper_list);
 190 }
 191
 192 static void
 193 h_hdl_new_remote_user(void *data)
 194 {
 195         struct Client *client_p = data;
 196         if (client_p->umodes & user_modes[UMODECHAR_HELPOPS])
 197                 helper_add(client_p);
 198 }
 199
 200 static void
 201 recurse_client_exit(struct Client *client_p)
 202 {
 203         if (IsPerson(client_p))
 204         {
 205                 if (client_p->umodes & user_modes[UMODECHAR_HELPOPS])
 206                         helper_delete(client_p);
 207         }
 208         else if (IsServer(client_p))
 209         {
 210                 rb_dlink_node *nptr;
 211
 212                 RB_DLINK_FOREACH(nptr, client_p->serv->users.head)
 213                         recurse_client_exit(nptr->data);
 214
 215                 RB_DLINK_FOREACH(nptr, client_p->serv->servers.head)
 216                         recurse_client_exit(nptr->data);
 217         }
 218 }
 219
 220 static void
 221 h_hdl_client_exit(void *data)
 222 {
 223         hook_data_client_exit *hdata = data;
 224         recurse_client_exit(hdata->target);
 225 }
 226
 227 static void
 228 h_hdl_umode_changed(void *data)
 229 {
 230         hook_data_umode_changed *hdata = data;
 231         struct Client *source_p = hdata->client;
 232
 233         /* didn't change +h umode, we don't need to do anything */
 234         bool changed = (hdata->oldumodes ^ source_p->umodes) & user_modes[UMODECHAR_HELPOPS];
 235
 236         if (source_p->umodes & user_modes[UMODECHAR_HELPOPS])
 237         {
 238                 if (MyClient(source_p) && !HasPrivilege(source_p, "usermode:helpops"))
 239                 {
 240                         source_p->umodes &= ~user_modes[UMODECHAR_HELPOPS];
 241                         sendto_one(source_p, form_str(ERR_NOPRIVS), me.name, source_p->name, "usermode:helpops");
 242                         /* they didn't ask for +h so we must be removing it */
 243                         if (!changed)
 244                                 helper_delete(source_p);
 245                         return;
 246                 }
 247
 248                 if (changed)
 249                         helper_add(source_p);
 250         }
 251         else if (changed)
 252         {
 253                 helper_delete(source_p);
 254         }
 255 }
 256
 257 static void
 258 h_hdl_whois(void *data)
 259 {
 260         hook_data_client *hdata = data;
 261         struct Client *source_p = hdata->client;
 262         struct Client *target_p = hdata->target;
 263
 264         if ((target_p->umodes & user_modes[UMODECHAR_HELPOPS]) && EmptyString(target_p->user->away))
 265         {
 266                 sendto_one_numeric(source_p, RPL_WHOISHELPOP, form_str(RPL_WHOISHELPOP), target_p->name);
 267         }
 268 }
 269
 270 DECLARE_MODULE_AV2(helpops, _modinit, _moddeinit, helpops_clist, NULL, helpops_hfnlist, NULL, NULL, helpops_desc);