join mute unreal

    /*
    *   m_joinmute.c adds a new channel mode: +J <seconds> which stops
    *   users which are not on channel for <seconds> from speaking.
    *   (C) 2009 Dvlpr
    *
    *   It is my first public module =P
    *
    *   See file AUTHORS in IRC package for additional names of
    *   the programmers.
    *
    *   This program is free software; you can redistribute it and/or modify
    *   it under the terms of the GNU General Public License as published by
    *   the Free Software Foundation; either version 1, or (at your option)
    *   any later version.
    *
    *   This program is distributed in the hope that it will be useful,
    *   but WITHOUT ANY WARRANTY; without even the implied warranty of
    *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    *   GNU General Public License for more details.
    *
    *   You should have received a copy of the GNU General Public License
    *   along with this program; if not, write to the Free Software
    *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
    */

    #include "config.h"
    #include "struct.h"
    #include "common.h"
    #include "sys.h"
    #include "numeric.h"
    #include "msg.h"
    #include "channel.h"
    #include <time.h>
    #include <sys/stat.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #ifdef _WIN32
    #include <io.h>
    #endif
    #include <fcntl.h>
    #include "h.h"
    #ifdef _WIN32
    #include "version.h"
    #endif

    #define DelHook(x)  if (x) HookDel(x); x = NULL
    Hook *HookJoin = NULL;
    Hook *HookPart = NULL;
    Hook *HookMessage = NULL;
    Hook *HookQuit = NULL;
    Hook *HookKick = NULL;
    static ModuleInfo   *thismodinfo = NULL;
    int cb_part(aClient *cptr, aClient *sptr, aChannel *chptr, char *parv[]);
    int cb_join(aClient *cptr, aClient *sptr, aChannel *chptr, char *parv[]);
    int cb_quit(aClient *sptr, char *comment);
    int cb_kick(aClient *cptr, aClient *sptr, aClient *who, aChannel *chptr, char *comment);
    DLLFUNC char *cb_msg(aClient *, aClient *, aChannel *, char *, int);
    #ifdef HOOKTYPE_REHASH_COMPLETE
    static int  cb_rehash_complete();
    Hook *HookRehashDone;
    #endif
    void add_user_to_memory(aClient *sptr, aChannel *chptr);


    typedef struct _channels_users_
    {
       struct _channel_users *prev, *next;
       aClient *source;
       aChannel *chptr;
       int joined_since;
    } UsersM;

    UsersM *muted_users; /* List of data */
    UsersM *FindUserInMemory(aClient *sptr, aChannel *chptr);
    void del_user_from_memory(UsersM *u);
    Cmode_t EXTCMODE_JOINMUTE = 0L;

    typedef struct {
       EXTCM_PAR_HEADER
       int seconds;
    } JoinMute;

    int modeJ_is_ok(aClient *sptr, aChannel *chptr, char *para, int checkt, int what);
    CmodeParam * modeJ_put_param(CmodeParam *lst, char *para);
    char *modeJ_get_param(CmodeParam *lst);
    char *modeJ_conv_param(char *param);
    void modeJ_free_param(CmodeParam *lst);
    CmodeParam *modeJ_dup_struct(CmodeParam *src);
    int modeJ_sjoin_check(aChannel *chptr, CmodeParam *ourx, CmodeParam *theirx);

    ModuleHeader MOD_HEADER(m_joinmute)
    = {
       "m_joinmute",
       "$Id: m_joinmute.c,v 0.1 2009/04/16 14:14 $",
       "Adds +J chmode: Join Mute for X seconds",
       "3.2-b8-1",
       NULL
    };

    DLLFUNC int MOD_TEST(m_joinmute)(ModuleInfo *modinfo)
    {

       return MOD_SUCCESS;
    }

    DLLFUNC int MOD_INIT(m_joinmute)(ModuleInfo *modinfo)
    {
       CmodeInfo req;
       thismodinfo = modinfo;
       ModuleSetOptions(modinfo->handle, MOD_OPT_PERM);
       memset(&req, 0, sizeof(req));
       req.paracount = 1;
       req.flag = 'J';
       req.is_ok = modeJ_is_ok;
       req.put_param = modeJ_put_param;
       req.get_param = modeJ_get_param;
       req.conv_param   = modeJ_conv_param;
       req.free_param = modeJ_free_param;
       req.dup_struct = modeJ_dup_struct;
       req.sjoin_check = modeJ_sjoin_check;
       CmodeAdd(thismodinfo->handle, req, &EXTCMODE_JOINMUTE);
       return MOD_SUCCESS;
    }

    DLLFUNC int MOD_LOAD(m_joinmute)(int module_load)
    {
       HookJoin = HookAddEx(thismodinfo->handle, HOOKTYPE_LOCAL_JOIN, cb_join);
       HookPart = HookAddEx(thismodinfo->handle, HOOKTYPE_LOCAL_PART, cb_part);
       HookMessage = HookAddPCharEx(thismodinfo->handle, HOOKTYPE_CHANMSG, cb_msg);
       HookQuit = HookAddEx(thismodinfo->handle, HOOKTYPE_LOCAL_QUIT, cb_quit);
       HookKick = HookAddEx(thismodinfo->handle, HOOKTYPE_LOCAL_KICK, cb_kick);

    #ifdef HOOKTYPE_REHASH_COMPLETE
       HookRehashDone   = HookAddEx(thismodinfo->handle, HOOKTYPE_REHASH_COMPLETE, cb_rehash_complete);
    #endif

       return MOD_SUCCESS;
    }

    DLLFUNC int MOD_UNLOAD(m_joinmute)(int module_unload)
    {
       DelHook(HookJoin);
       DelHook(HookPart);
       DelHook(HookMessage);
       DelHook(HookQuit);

    #ifdef HOOKTYPE_REHASH_COMPLETE
       DelHook(HookRehashDone);
    #endif

       return MOD_SUCCESS;
    }

    int modeJ_is_ok(aClient *sptr, aChannel *chptr, char *para, int checkt, int what)
    {
       int seconds;
       if(what == MODE_ADD)
       seconds = atoi(para);
       if ((checkt == EXCHK_ACCESS) || (checkt == EXCHK_ACCESS_ERR))
       {
          if (IsPerson(sptr) && is_chan_op(sptr, chptr))
             return EX_ALLOW;
          if (checkt == EXCHK_ACCESS_ERR) /* can only be due to being halfop */
             sendto_one(sptr, err_str(ERR_NOTFORHALFOPS), me.name, sptr->name, 'J');
          return EX_DENY;
       }
          else if (checkt == EXCHK_PARAM)
       {
          if(seconds < 0 || seconds > 65536)
          {
             sendnotice(sptr, "*** [ERROR] Seconds value is out of range!");
             return EX_DENY;
          }
          return EX_ALLOW;
       }
       return 0;
    }

    CmodeParam * modeJ_put_param(CmodeParam *r_in, char *param)
    {
    JoinMute *r = (JoinMute *)r_in;
    int seconds = atoi(param);

       if (!r)
       {
          /* Need to create one */
          r = (JoinMute *)malloc(sizeof(JoinMute));
          memset(r, 0, sizeof(JoinMute));
          r->flag = 'J';
       }
       if(seconds < 0 || seconds > 65536)
          seconds = 0;
       r->seconds = seconds;
       return (CmodeParam *)r;
    }

    char *modeJ_get_param(CmodeParam *r_in)
    {
    JoinMute *r = (JoinMute *)r_in;
    static char retbuf[16];

       if (!r)
          return NULL;

       snprintf(retbuf, sizeof(retbuf), "%d", r->seconds);
       return retbuf;
    }

    char *modeJ_conv_param(char *param_in)
    {
    static char retbuf[32];
    int num = atoi(param_in);

       if(num < 0)
          num = 0;
       else if(num > 65536)
          num = 255;
       else if(!num)
          num = 0;

       snprintf(retbuf, sizeof(retbuf), "%d", num);
              return retbuf;
    }

    void modeJ_free_param(CmodeParam *r)
    {
       JoinMute *n = (JoinMute *)r;
       free(n);
       return;
    }

    CmodeParam *modeJ_dup_struct(CmodeParam *r_in)
    {
    JoinMute *n = (JoinMute *)malloc(sizeof(JoinMute));
       memcpy(n, r_in, sizeof(JoinMute));
       return (CmodeParam *)n;
    }

    int modeJ_sjoin_check(aChannel *chptr, CmodeParam *ourx, CmodeParam *theirx)
    {
       JoinMute *our = (JoinMute *)ourx;
       JoinMute *their = (JoinMute *)theirx;
       if (our->seconds == their->seconds)
          return EXSJ_SAME;
       if (our->seconds > their->seconds) /* Server with more seconds winning */
          return EXSJ_WEWON;
       else
          return EXSJ_THEYWON;
    }

    /** add_user_to_memory
    * Adds user to currently muted users list
    * Allocates the memory for data
    */

    void add_user_to_memory(aClient *sptr, aChannel *chptr)
    {
       UsersM *u = (UsersM *) MyMallocEx(sizeof(UsersM));
       if(!u)
          return;
       u->chptr = chptr;
       u->source = sptr;
       u->joined_since = TStime();
       AddListItem(u, muted_users);
       return;
    }

    /** del_user_from_memory
    * Removes user from currently muted users list
    * Frees the memory allocated for data
    */

    void del_user_from_memory(UsersM *u)
    {
       if(!u)
          return;
       DelListItem(u, muted_users);
       MyFree(u);
       return;
    }

    /** FindUserInMemory
    * Scans through currently muted users
    * to find matching one, if the user is found
    * its pointer will be returned instantly
    */
    UsersM *FindUserInMemory(aClient *sptr, aChannel *chptr)
    {
       UsersM *uz;
       for(uz = muted_users; uz; uz = (UsersM *)uz->next)
       {
          if(!find_client(uz->source->name, NULL))
          {
             del_user_from_memory(uz);
             continue;
          }
          if(!IsMember(uz->source, uz->chptr))
          {
             del_user_from_memory(uz);
             continue;
          }
          if(!(uz->chptr->mode.extmode & EXTCMODE_JOINMUTE))
          {
             del_user_from_memory(uz);
             continue;
          }
          if((uz->source == sptr) && (uz->chptr == chptr))
             return uz;
       }
       return NULL;
    }


    /* Used on quit - just remove all entries with sptr as a user */
    void clear_matching_entries(aClient *sptr)
    {
       UsersM *userz;
       for(userz = muted_users; userz; userz = (UsersM *)userz->next)
       {
          if(userz->source == sptr)
             del_user_from_memory(userz);
       }
    }


    DLLFUNC char *cb_msg(aClient *cptr, aClient *sptr, aChannel *chptr, char *text, int notice)
    {
       JoinMute *para = (JoinMute *)extcmode_get_struct(chptr->mode.extmodeparam, 'J');
       UsersM *u;
       if(!MyClient(sptr))
          return text;
       u = FindUserInMemory(sptr, chptr); /* Let's find entry in muted users list :) */
       /* hops/vops/ops are allowed to send it... */
       if(is_chan_op(sptr, chptr) || is_half_op(sptr, chptr) || has_voice(sptr, chptr) || IsAnOper(sptr))
          return text;
       if(!(chptr->mode.extmode & EXTCMODE_JOINMUTE))
          return text;
       if(!u)
          return text; /* Not found - let it be sent! -- Dvlpr */
       if((TStime() - u->joined_since) > para->seconds) /* How we know if user allowed? we just check if current time - time when user
                                                 * joined the channel is more then seconds and if yes, we allow sending text + deleting
                                                 * user's data from muted users list */
       {
          del_user_from_memory(u);
          return text;
       }
       /* 404! :] -- Dvlpr */
       sendto_one(sptr, ":%s 404 %s %s :Cannot send to channel: you must wait %d seconds after joining"
              " to speak", me.name, sptr->name, chptr->chname, para->seconds);
       return NULL;

    }

    int cb_join(aClient *cptr, aClient *sptr, aChannel *chptr, char *parv[])
    {
       add_user_to_memory(sptr, chptr);
       return HOOK_CONTINUE;
    }

    int cb_part(aClient *cptr, aClient *sptr, aChannel *chptr, char *parv[])
    {
       UsersM *u = FindUserInMemory(sptr, chptr);
       if(!u)
          return HOOK_CONTINUE;
       del_user_from_memory(u);

       return HOOK_CONTINUE;
    }

    int cb_quit(aClient *sptr, char *comment)
    {
       clear_matching_entries(sptr);
       return HOOK_CONTINUE;
    }

    int cb_kick(aClient *cptr, aClient *sptr, aClient *who, aChannel *chptr, char *comment)
    {
       UsersM *u = FindUserInMemory(who, chptr);
       if(!u)
          return HOOK_CONTINUE;
       del_user_from_memory(u);

       return HOOK_CONTINUE;
    }


    #ifdef HOOKTYPE_REHASH_COMPLETE
    static int cb_rehash_complete()
    {
       HookJoin = HookAddEx(thismodinfo->handle, HOOKTYPE_LOCAL_JOIN, cb_join);
       HookPart = HookAddEx(thismodinfo->handle, HOOKTYPE_LOCAL_PART, cb_part);
       HookMessage = HookAddPCharEx(thismodinfo->handle, HOOKTYPE_CHANMSG, cb_msg);
       HookQuit = HookAddEx(thismodinfo->handle, HOOKTYPE_LOCAL_QUIT, cb_quit);
       HookKick = HookAddEx(thismodinfo->handle, HOOKTYPE_LOCAL_KICK, cb_kick);
       return HOOK_CONTINUE;
    }
    #endif