| AlwaysGooD | 20 Ekim 2006 00:06 |
Join-Part saldirilari icin module
Join part saldirilari icin jointhrottle üzerinden çalışmış olduğum module'dur. Join part yapan botları tespit edip gzline atıyor. /mode #kanal +J 1:10
olarak ayarlamamız gerekiyor. Bu modu sadece ircop ve adminler kullanabiliyor... Kod:
/*
* AlwaysGooD ( ALTUĞ KARAALİ) tarafından düzenlenmiştir.
*/
#include "config.h"
#include "struct.h"
#include "common.h"
#include "sys.h"
#include "numeric.h"
#include "msg.h"
#include "proto.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 STRIPBADWORDS
#include "badwords.h"
#endif
#ifdef _WIN32
#include "version.h"
#endif
#ifndef EXTCMODE
#error "This module requires extended channel modes to be enabled."
#error "See the EXTCMODE macro in include/config.h for more information."
#error "Compilation aborted." f
#endif
#define FLAG_joinpart 'J'
#define ERR_TOOMUCHJOINS 496
#define HasJoinLimit(x) ((x)->mode.extmode & MODE_joinpart)
#define ClearMem(x) memset(&(x), 0, sizeof (x))
#define DelCmode(x) if (x) CmodeDel(x); x = NULL
#define DelHook(x) if (x) HookDel(x); x = NULL
/* Backward compatibility */
#ifndef EX_DENY
#define EX_DENY 0
#define EX_ALLOW 1
#define EX_ALWAYS_DENY 0
#endif
#ifndef HOOK_CONTINUE
#define HOOK_CONTINUE 0
#define HOOK_ALLOW -1
#define HOOK_DENY 1
#endif
typedef struct
{
EXTCM_PAR_HEADER
int joins;
long seconds;
} aModeJTEntry;
typedef struct _joinflood JoinFlood;
struct _joinflood
{
JoinFlood *prev, *next;
aChannel *chptr;
aClient *sptr;
int joins;
TS last;
};
static Cmode *AddCmode(Module *module, CmodeInfo *req, Cmode_t *mode);
static int ModeJT_is_ok(aClient *, aChannel *, char *, int, int);
static CmodeParam *ModeJT_put_param(CmodeParam *, char *);
static char *ModeJT_get_param(CmodeParam *);
static char *ModeJT_conv_param(char *);
static void ModeJT_free_param(CmodeParam *);
static CmodeParam *ModeJT_dup_struct(CmodeParam *);
static int ModeJT_sjoin_check(aChannel *, CmodeParam *, CmodeParam *);
static int cb_channel_destroy(aChannel *);
static int cb_join(aClient *, aChannel *, char *[]);
static int cb_quit(aClient *, char *);
static void InitConf();
static void FreeConf();
Cmode_t MODE_joinpart = 0L;
JoinFlood *JFlist;
ModuleHeader MOD_HEADER(joinpart)
= {
"Join+Part Flood",
"v1.0",
"Kanal mod +J join flood banned Administrator.",
"3.2-b8-1",
NULL
};
DLLFUNC int MOD_TEST(joinpart)(ModuleInfo *modinfo)
{
CmodeInfo ModeJT;
ClearMem(ModeJT);
ModeJT.flag = FLAG_joinpart;
ModeJT.paracount = 1;
ModeJT.is_ok = ModeJT_is_ok;
ModeJT.put_param = ModeJT_put_param;
ModeJT.get_param = ModeJT_get_param;
ModeJT.conv_param = ModeJT_conv_param;
ModeJT.free_param = ModeJT_free_param;
ModeJT.sjoin_check = ModeJT_sjoin_check;
ModeJT.dup_struct = ModeJT_dup_struct;
AddCmode(modinfo->handle, &ModeJT, &MODE_joinpart);
return MOD_SUCCESS;
}
DLLFUNC int MOD_INIT(joinpart)(ModuleInfo *modinfo)
{
ModuleSetOptions(modinfo->handle, MOD_OPT_PERM);
InitConf();
HookAddEx(modinfo->handle, HOOKTYPE_PRE_LOCAL_JOIN, cb_join);
HookAddEx(modinfo->handle, HOOKTYPE_CHANNEL_DESTROY, cb_channel_destroy);
HookAddEx(modinfo->handle, HOOKTYPE_LOCAL_QUIT, cb_quit);
HookAddEx(modinfo->handle, HOOKTYPE_REMOTE_QUIT, cb_quit);
return MOD_SUCCESS;
}
DLLFUNC int MOD_LOAD(joinpart)(int module_load)
{
return MOD_SUCCESS;
}
DLLFUNC int MOD_UNLOAD(joinpart)(int module_unload)
{
FreeConf();
return MOD_SUCCESS;
}
static void InitConf()
{
JFlist = NULL;
}
static void FreeConf()
{
JoinFlood *J;
ListStruct *next;
for (J = JFlist; J; J = (JoinFlood *) next)
{
next = (ListStruct *) J->next;
DelListItem(J, JFlist);
MyFree(J);
}
}
static Cmode *AddCmode(Module *module, CmodeInfo *req, Cmode_t *mode)
{
Cmode *cmode;
*mode = 0;
cmode = CmodeAdd(module, *req, mode);
if (ModuleGetError(module) != MODERR_NOERROR || !cmode)
{
config_error("Error adding channel mode +%c when loading module %s: %s",
req->flag, MOD_HEADER(joinpart).name, ModuleGetErrorStr(module));
return NULL;
}
return cmode;
}
static int cb_channel_destroy(aChannel *chptr)
{
JoinFlood *J;
ListStruct *next;
for (J = JFlist; J; J = (JoinFlood *) next)
{
next = (ListStruct *) J->next;
if (J->chptr == chptr)
{
DelListItem(J, JFlist);
MyFree(J);
}
}
return 0;
}
static int cb_quit(aClient *sptr, char *comment)
{
JoinFlood *J;
ListStruct *next;
for (J = JFlist; J; J = (JoinFlood *) next)
{
next = (ListStruct *) J->next;
if (J->sptr == sptr)
{
DelListItem(J, JFlist);
MyFree(J);
}
}
return 0;
}
static int cb_join(aClient *sptr, aChannel *chptr, char *parv[])
{
JoinFlood *J;
aModeJTEntry *p;
TS now = TStime();
if (!HasJoinLimit(chptr))
return HOOK_CONTINUE;
for (J = JFlist; J; J = J->next)
if ((J->chptr == chptr && J->sptr == sptr))
break;
if (!J)
{
J = (JoinFlood *) MyMallocEx(sizeof(JoinFlood));
J->sptr = sptr;
J->chptr = chptr;
J->last = now;
J->joins = 1;
AddListItem(J, JFlist);
}
else
{
p = (aModeJTEntry *) extcmode_get_struct(chptr->mode.extmodeparam, FLAG_joinpart);
if (now - J->last >= p->seconds)
{
J->last = now;
J->joins = 1;
}
else
{
J->joins++;
if (J->joins > p->joins && now - J->last < p->seconds)
{
#ifndef NO_OPEROVERRIDE
if (IsOper(sptr) && OPCanOverride(sptr))
{
sendto_snomask(SNO_EYES,
"*** OperOverride -- %s (%s@%s) joined %s (overriding +%c).",
sptr->name, sptr->user->username, sptr->user->realhost,
chptr->chname, FLAG_joinpart);
return HOOK_CONTINUE;
}
#endif
place_host_ban(sptr, BAN_ACT_GZLINE, "Join+Part Saldirisi yaptığınız tespit edilmiştir. [MTS]", 864000);
sendto_one(sptr, ":Join Part yaptiniz"
"[Reksnet Protection Systems].",
me.name, ERR_TOOMUCHJOINS, parv[0], chptr->chname,
J->last + p->seconds - now);
return HOOK_DENY;
}
}
}
return HOOK_CONTINUE;
}
static int ModeJT_is_ok(aClient *sptr, aChannel *chptr, char *param, int type, int what)
{
char *p;
int num;
long sec;
int ok;
if (type == EXCHK_ACCESS || type == EXCHK_ACCESS_ERR)
{
if (!IsPerson(sptr) || IsULine(sptr))
return EX_ALLOW;
if (!IsOper(sptr))
{
if (type == EXCHK_ACCESS_ERR)
sendto_one(sptr, err_str(ERR_CHANOPRIVSNEEDED),
me.name, sptr->name, chptr->chname);
sendto_one(sptr, "Chanserv notice %s :Bu mod sadece operlar tarafindan kullanilmaktadir.", me.name, sptr->name);
return EX_DENY;
}
return EX_ALLOW;
}
else if (type == EXCHK_PARAM)
{
ok = 1;
p = strchr(param, ':');
if (!p)
{
ok = 0;
sendnotice(sptr, "Kanal modu +%c giris:saniye seklinde olacaktir.",
FLAG_joinpart);
}
else
{
*p = '\0';
num = atoi(param);
sec = config_checkval(p+1, CFG_TIME);
if (num < 1 || sec < 1 || num > 10000 || sec > 86400)
{
ok = 0;
sendnotice(sptr, "Parameter for channel mode +%c is out of range",
FLAG_joinpart);
}
*p = ':';
}
return ok;
}
return 0;
}
static CmodeParam *ModeJT_put_param(CmodeParam *param, char *text)
{
aModeJTEntry *m = (aModeJTEntry *) param;
char *p;
if (!m)
{
m = (aModeJTEntry *) MyMallocEx(sizeof(aModeJTEntry));
m->flag = FLAG_joinpart;
}
p = strchr(text, ':');
*p = '\0';
m->joins = atoi(text);
m->seconds = config_checkval(p+1, CFG_TIME);
*p = ':';
return (CmodeParam *)m;
}
static char *ModeJT_get_param(CmodeParam *param)
{
aModeJTEntry *m = (aModeJTEntry *)param;
static char text[64];
if (!m)
return NULL;
ClearMem(text);
sprintf(text, "%d:%ld", m->joins, m->seconds);
return text;
}
static char *ModeJT_conv_param(char *in)
{
int joins;
long seconds;
static char text[64];
char *p;
p = strchr(in, ':');
*p = '\0';
joins = atoi(in);
seconds = config_checkval(p+1, CFG_TIME);
*p = ':';
ClearMem(text);
sprintf(text, "%d:%ld", joins, seconds);
return text;
}
static void ModeJT_free_param(CmodeParam *param)
{
MyFree(param);
}
static CmodeParam *ModeJT_dup_struct(CmodeParam *in)
{
aModeJTEntry *m = MyMalloc(sizeof(aModeJTEntry));
memcpy(m, in, sizeof(aModeJTEntry));
m->prev = m->next = NULL;
return (CmodeParam *) m;
}
static int ModeJT_sjoin_check(aChannel *chptr, CmodeParam *ours, CmodeParam *theirs)
{
aModeJTEntry *o = (aModeJTEntry *)ours;
aModeJTEntry *t = (aModeJTEntry *)theirs;
if ((o->joins == t->joins) && (o->seconds == t->seconds))
return EXSJ_SAME;
if (o->seconds < t->seconds)
return EXSJ_THEYWON;
else if (o->joins < t->joins)
return EXSJ_THEYWON;
else
return EXSJ_WEWON;
}
|
