/*
* Teqnic  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" 
"[SekerShell 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; 
}