IRCForumları - IRC ve mIRC Kullanıcılarının Buluşma Noktası

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; 

}