| ExcLuSive | 25 Mart 2018 01:09 |
Oper Ekleme Modülü Kısıtlama hk.
Merhaba unreal telnete girmeden ekle modulün de network adminler oper ekleme silme yapabiliyor buna kısıtlama nasıl koyabilirim? Rootadmin eklentisi mevcut sunucuda U flagı sadece root adminler eklesin şeklinde olabiliir yada farklı bir yönetem. Kod:
/*
* =================================================================
* Editor :--
* =================================================================
*/
#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 STRIPBADWORDS
#include "badwords.h"
#endif
#ifdef _WIN32
#include "version.h"
#endif
typedef struct _conf_operflag OperFlag;
typedef struct _blocklist BlockList;
typedef struct _operpass OperPass;
typedef struct _cmdinfo CmdInfo;
struct _conf_operflag
{
long flag;
char *name;
};
struct _operpass
{
OperPass *prev, *next;
aClient *cptr;
};
struct _blocklist
{
BlockList *prev, *next;
ConfigItem_oper *oper;
};
struct _cmdinfo
{
char *msg, *tok;
iFP func;
Command *cmd;
};
extern void sendto_one(aClient *to, char *pattern, ...);
extern void sendto_serv_butone_token(aClient *one, char *prefix, char *command, char *token, char *pattern, ...);
extern OperFlag *config_binary_flags_search(OperFlag *table, char *cmd, int size);
extern anAuthStruct AuthTypes[];
#define OPER_DB "yetki.db"
#define OPER_DB_VERSION 1001
#define ircstrdup(x,y) if (x) MyFree(x); if (!y) x = NULL; else x = strdup(y)
#define ircfree(x) if (x) MyFree(x); x = NULL
#define IsParam(x) (parc > (x) && !BadPtr(parv[(x)]))
#define IsNotParam(x) (parc <= (x) || BadPtr(parv[(x)]))
#define DelCommand(x) if (x) CommandDel(x); x = NULL
#define DelHook(x) if (x) HookDel(x); x = NULL
/* Helpful macros to make the code a bit more readable */
#define FromLoop(counter, list) \
for (counter = (ConfigItem_oper_from *) list; \
counter; counter = (ConfigItem_oper_from *) (counter)->next)
#define FromLoop2(counter, list, next) \
for (counter = (ConfigItem_oper_from *) list; \
counter; counter = (ConfigItem_oper_from *) next)
#define NewFrom \
(ConfigItem_oper_from *) MyMallocEx(sizeof(ConfigItem_oper_from))
#define OF_NAME 0x01
#define OF_SWHOIS 0x02
#define OF_SNOMASK 0x04
#define OF_MAXLOGINS 0x08
#define OF_PASSWORD 0x10
#define OF_USERHOST 0x20
#define OF_FLAGS 0x40
#define OF_CLASS 0x80
#define OF_TABLESIZE sizeof(_OperFields)/sizeof(_OperFields[0])
static CMD_FUNC(m_addoper);
static CMD_FUNC(m_addroper);
static CMD_FUNC(m_addgoper);
static CMD_FUNC(m_deloper);
static CMD_FUNC(m_delroper);
static CMD_FUNC(m_delgoper);
static CMD_FUNC(m_modoper);
static CMD_FUNC(m_modroper);
static CMD_FUNC(m_modgoper);
static CMD_FUNC(m_confoper);
static CMD_FUNC(m_confroper);
static CMD_FUNC(m_masterpass);
static Command *AddCommand(Module *module, char *msg, char *token, iFP func);
static int add_commands(Module *module);
static void del_commands();
static int cb_config_rehash();
static int cb_rehash_complete();
static int cb_test(ConfigFile *, ConfigEntry *, int, int *);
static int cb_conf(ConfigFile *, ConfigEntry *, int);
static int cb_stats(aClient *sptr, char *stats);
static int cb_quit(aClient *, char *);
static int save_opers();
static int load_opers();
static void free_extopers();
static void free_operpasslist();
static OperPass *FindOperPass(aClient *cptr);
static BlockList *FindExternalOper(ConfigItem_oper *oper);
static Hook *HookConfTest, *HookConfRun, *HookStats;
static Hook *HookQuit;
static Hook *HookConfRehash;
static Hook *HookRehashDone;
static anAuthStruct *opers_auth;
static BlockList *ExternalOpers;
static OperPass *OperPassList;
static char buf[1024];
static unsigned oper_db_version = OPER_DB_VERSION;
static CmdInfo OperCommands[] =
{
{ "ekle", "OA", m_addoper, NULL },
{ "ekle1", "ORA", m_addroper, NULL },
{ "ekle2", "OGA", m_addgoper, NULL },
{ "sil", "OD", m_deloper, NULL },
{ "sil1", "ORD", m_delroper, NULL },
{ "sil2", "OGD", m_delgoper, NULL },
{ "fsd1", "OM", m_modoper, NULL },
{ "fsd2", "ORM", m_modroper, NULL },
{ "fsd3", "OGM", m_modgoper, NULL },
{ "fsd4", "OC", m_confoper, NULL },
{ "fsd5", "ORC", m_confroper, NULL },
{ "fsddegis", "MP", m_masterpass, NULL },
{ NULL, NULL, NULL, NULL }
};
static int _OldOperFlags[] =
{
OFLAG_LOCAL, 'o',
OFLAG_GLOBAL, 'O',
OFLAG_REHASH, 'r',
OFLAG_DIE, 'D',
OFLAG_RESTART, 'R',
OFLAG_HELPOP, 'h',
OFLAG_GLOBOP, 'g',
OFLAG_WALLOP, 'w',
OFLAG_LOCOP, 'l',
OFLAG_LROUTE, 'c',
OFLAG_GROUTE, 'L',
OFLAG_LKILL, 'k',
OFLAG_GKILL, 'K',
OFLAG_KLINE, 'b',
OFLAG_UNKLINE, 'B',
OFLAG_LNOTICE, 'n',
OFLAG_GNOTICE, 'G',
OFLAG_ADMIN_, 'A',
OFLAG_SADMIN_, 'a',
OFLAG_NADMIN, 'N',
OFLAG_COADMIN, 'C',
OFLAG_ZLINE, 'z',
OFLAG_WHOIS, 'W',
OFLAG_HIDE, 'H',
OFLAG_TKL, 't',
OFLAG_GZL, 'Z',
OFLAG_OVERRIDE, 'v',
OFLAG_UMODEQ, 'q',
OFLAG_DCCDENY, 'd',
0, 0
};
/* This MUST be alphabetized */
static OperFlag _OperFields[] =
{
{ OF_CLASS, "class" },
{ OF_FLAGS, "flags" },
{ OF_MAXLOGINS, "maxlogins" },
{ OF_NAME, "name" },
{ OF_PASSWORD, "password" },
{ OF_SNOMASK, "snomask" },
{ OF_SWHOIS, "swhois" },
{ OF_USERHOST, "userhost" },
};
ModuleHeader MOD_HEADER(opers)
= {
"OperEkle",
"Oper Ekle modulu",
"Oto Opers Sistemi",
"3.2-b8-1",
NULL
};
static void InitConf()
{
opers_auth = NULL;
ExternalOpers = NULL;
}
static void FreeConf()
{
if (opers_auth)
Auth_DeleteAuthStruct(opers_auth);
free_extopers();
}
DLLFUNC int MOD_TEST(opers)(ModuleInfo *modinfo)
{
HookConfTest = HookAddEx(modinfo->handle, HOOKTYPE_CONFIGTEST, cb_test);
return MOD_SUCCESS;
}
DLLFUNC int MOD_INIT(opers)(ModuleInfo *modinfo)
{
#ifndef STATIC_LINKING
ModuleSetOptions(modinfo->handle, MOD_OPT_PERM);
#endif
InitConf();
HookQuit = HookAddEx(modinfo->handle, HOOKTYPE_LOCAL_QUIT, cb_quit);
HookConfRehash = HookAddEx(modinfo->handle, HOOKTYPE_REHASH, cb_config_rehash);
HookRehashDone = HookAddEx(modinfo->handle, HOOKTYPE_REHASH_COMPLETE, cb_rehash_complete);
HookConfRun = HookAddEx(modinfo->handle, HOOKTYPE_CONFIGRUN, cb_conf);
HookStats = HookAddEx(modinfo->handle, HOOKTYPE_STATS, cb_stats);
return add_commands(modinfo->handle);
}
DLLFUNC int MOD_LOAD(opers)(int module_load)
{
load_opers();
return MOD_SUCCESS;
}
DLLFUNC int MOD_UNLOAD(opers)(int module_unload)
{
FreeConf();
free_operpasslist();
del_commands();
DelHook(HookStats);
DelHook(HookConfRun);
DelHook(HookRehashDone);
DelHook(HookConfRehash);
DelHook(HookQuit);
DelHook(HookConfTest);
return MOD_SUCCESS;
}
static Command *AddCommand(Module *module, char *msg, char *token, iFP func)
{
Command *cmd;
if (CommandExists(msg))
{
config_error("Bu komut %s zaten kullanilmistir.", msg);
return NULL;
}
if (CommandExists(token))
{
config_error("Bu komut %s zaten kullanilmistir.", token);
return NULL;
}
cmd = CommandAdd(module, msg, token, func, MAXPARA, 0);
#ifndef STATIC_LINKING
if (ModuleGetError(module) != MODERR_NOERROR || !cmd)
#else
if (!cmd)
#endif
{
#ifndef STATIC_LINKING
config_error("Dikkat: islem Basarisizdir. Sonuc: %s: %s", msg,
ModuleGetErrorStr(module));
#else
config_error("Dikkat: islem Basarisizdir. Sonuc: %s", msg);
#endif
return NULL;
}
return cmd;
}
static int add_commands(Module *module)
{
CmdInfo *p;
int ret = MOD_SUCCESS;
for (p = OperCommands; p->msg; p++)
{
p->cmd = AddCommand(module, p->msg, p->tok, p->func);
if (!p->cmd)
ret = MOD_FAILED;
}
return ret;
}
static void del_commands()
{
CmdInfo *p;
for (p = OperCommands; p->msg; p++)
{
DelCommand(p->cmd);
}
}
static int cb_config_rehash()
{
FreeConf();
InitConf();
return 0;
}
static int cb_rehash_complete()
{
load_opers();
return 0;
}
static int cb_quit(aClient *sptr, char *comment)
{
OperPass *p;
for (p = OperPassList; p; p = p->next)
if (p->cptr == sptr)
break;
if (p)
{
DelListItem(p, OperPassList);
MyFree(p);
}
return 0;
}
static int cb_test(ConfigFile *cf, ConfigEntry *ce, int type, int *errs)
{
int errors = 0;
if (type != CONFIG_SET)
return 0;
if (!strcmp(ce->ce_varname, "master-password"))
{
if (!ce->ce_vardata)
{
config_error("%s:%i: set::master-password master sifresini giriniz.",
ce->ce_fileptr->cf_filename,
ce->ce_varlinenum);
errors++;
}
else if (Auth_CheckError(ce) < 0)
errors++;
*errs = errors;
return errors ? -1 : 1;
}
else
return 0;
}
static int cb_conf(ConfigFile *cf, ConfigEntry *ce, int type)
{
if (type != CONFIG_SET)
return 0;
if (!strcmp(ce->ce_varname, "master-password"))
{
if (opers_auth)
Auth_DeleteAuthStruct(opers_auth);
opers_auth = Auth_ConvertConf2AuthStruct(ce);
return 1;
}
return 0;
}
static int cb_stats(aClient *sptr, char *stats)
{
if (*stats == 'S')
{
sendto_one(sptr, ":%s %i %s :master-password: <%s>",
me.name, RPL_TEXT, sptr->name, opers_auth ? "hidden" : "none");
}
return 0;
}
static void free_operpasslist()
{
OperPass *p;
ListStruct *next;
for (p = OperPassList; p; p = (OperPass *) next)
{
next = (ListStruct *) p->next;
DelListItem(p, OperPassList);
MyFree(p);
}
}
static OperPass *FindOperPass(aClient *cptr)
{
OperPass *p;
for (p = OperPassList; p; p = p->next)
if (p->cptr == cptr)
break;
return p;
}
static void AddOperPass(aClient *cptr)
{
OperPass *p;
p = (OperPass *) MyMalloc(sizeof(OperPass));
p->cptr = cptr;
AddListItem(p, OperPassList);
}
static BlockList *FindExternalOper(ConfigItem_oper *oper)
{
BlockList *p;
for (p = ExternalOpers; p; p = p->next)
if (p->oper == oper)
break;
return p;
}
static void AddExternalOper(ConfigItem_oper *oper)
{
BlockList *p;
p = (BlockList *) MyMalloc(sizeof(BlockList));
p->oper = oper;
AddListItem(p, ExternalOpers);
}
inline static void DelExternalOper(BlockList *extoper)
{
DelListItem(extoper, ExternalOpers);
MyFree(extoper);
}
static void free_extopers()
{
BlockList *p;
ListStruct *next;
for (p = ExternalOpers; p; p = (BlockList *) next)
{
next = (ListStruct *) p->next;
DelListItem(p, ExternalOpers);
MyFree(p);
}
}
// =========================================================================
static void free_oper(ConfigItem_oper *oper)
{
ListStruct *next;
ConfigItem_oper_from *from;
ircfree(oper->name);
ircfree(oper->swhois);
ircfree(oper->snomask);
Auth_DeleteAuthStruct(oper->auth);
FromLoop2(from, oper->from, next)
{
next = (ListStruct *) from->next;
DelListItem(from, oper->from);
ircfree(from->name);
MyFree(from);
}
MyFree(oper);
}
// =========================================================================
#ifndef _WIN32
#define OpenFile(fd, file, flags) fd = open(file, flags, S_IRUSR|S_IWUSR)
#else
#define OpenFile(fd, file, flags) fd = open(file, flags, S_IREAD|S_IWRITE)
#endif
#define R_SAFE(x) \
do { \
if ((x)) \
{ \
close(fd); \
if (oper) \
free_oper(oper); \
config_error("Okunamadi !!! : %s", OPER_DB); \
return -1; \
} \
} while (0)
#define RF_SAFE(x) \
do { \
if ((x)) \
{ \
close(fd); \
if (oper) \
free_oper(oper); \
ircfree(from); \
config_error("Okunamadi !!! : %s", OPER_DB); \
return -1; \
} \
} while (0)
#define W_SAFE(x) \
do { \
if ((x)) \
{ \
close(fd); \
config_error("Yazilim Hatasi %s", OPER_DB); \
return -1; \
} \
} while (0)
static inline int read_data(int fd, void *buf, size_t count)
{
if ((size_t) read(fd, buf, count) < count)
return -1;
return 0;
}
static inline int write_data(int fd, void *buf, size_t count)
{
if ((size_t) write(fd, buf, count) < count)
return -1;
return 0;
}
static int write_str(int fd, char *x)
{
size_t count = x ? strlen(x) : 0;
if (write_data(fd, &count, sizeof count))
return -1;
if (count)
{
if (write_data(fd, x, sizeof(char) * count))
return -1;
}
return 0;
}
static int read_str(int fd, char **x)
{
size_t count;
if (read_data(fd, &count, sizeof count))
return -1;
if (!count)
{
*x = NULL;
return 0;
}
*x = (char *) MyMalloc(sizeof(char) * count + 1);
if (read_data(fd, *x, sizeof(char) * count))
{
MyFree(*x);
*x = NULL;
return -1;
}
(*x)[count] = 0;
return 0;
}
static int save_opers()
{
ConfigItem_oper *oper;
ConfigItem_oper_from *from;
int fd;
size_t count, fromcount;
OpenFile(fd, OPER_DB, O_CREAT | O_WRONLY | O_TRUNC);
if (fd == -1)
{
config_status("Hata: %s %s Dosyasina Yazilamadi.",
OPER_DB, strerror(errno));
return -1;
}
W_SAFE(write_data(fd, &oper_db_version, sizeof oper_db_version));
count = 0;
for (oper = conf_oper; oper; oper = (ConfigItem_oper *) oper->next)
if (FindExternalOper(oper))
count++;
W_SAFE(write_data(fd, &count, sizeof count));
for (oper = conf_oper; oper; oper = (ConfigItem_oper *) oper->next)
{
if (!FindExternalOper(oper))
continue;
W_SAFE(write_str(fd, oper->name));
W_SAFE(write_str(fd, oper->swhois));
W_SAFE(write_str(fd, oper->snomask));
W_SAFE(write_str(fd, oper->auth->data));
W_SAFE(write_data(fd, &oper->auth->type, sizeof oper->auth->type));
W_SAFE(write_str(fd, oper->class->name));
W_SAFE(write_data(fd, &oper->oflags, sizeof oper->oflags));
W_SAFE(write_data(fd, &oper->maxlogins, sizeof oper->maxlogins));
fromcount = 0;
FromLoop(from, oper->from)
fromcount++;
W_SAFE(write_data(fd, &fromcount, sizeof fromcount));
FromLoop(from, oper->from)
W_SAFE(write_str(fd, from->name));
}
close(fd);
return 0;
}
static int load_opers()
{
ConfigItem_oper *oper = NULL;
ConfigItem_oper_from *from = NULL;
char *class;
int fd;
size_t count, fromcount, i, j;
unsigned version;
OpenFile(fd, OPER_DB, O_RDONLY);
if (fd == -1)
{
if (errno != ENOENT)
config_status("Hata: %s %s Dosyasina Yazilamadi.",
OPER_DB, strerror(errno));
return -1;
}
R_SAFE(read_data(fd, &version, sizeof version));
if (version != oper_db_version)
{
config_status("File %s has a wrong database version (expected: %u, got: %u)",
OPER_DB, oper_db_version, version);
close(fd);
return -1;
}
R_SAFE(read_data(fd, &count, sizeof count));
for (i = 1; i <= count; i++)
{
from = NULL;
oper = MyMallocEx(sizeof(ConfigItem_oper));
oper->auth = (anAuthStruct *) MyMallocEx(sizeof(anAuthStruct));
R_SAFE(read_str(fd, &oper->name));
R_SAFE(read_str(fd, &oper->swhois));
R_SAFE(read_str(fd, &oper->snomask));
R_SAFE(read_str(fd, &oper->auth->data));
R_SAFE(read_data(fd, &oper->auth->type, sizeof oper->auth->type));
R_SAFE(read_str(fd, &class));
oper->class = Find_class(class);
if (!oper->class)
{
config_status("Dikkat: '%s' Nickli oper (%s), Hatayi verdi. Bakınız: (%s)",
oper->name, class, default_class->name);
oper->class = default_class;
}
ircfree(class);
R_SAFE(read_data(fd, &oper->oflags, sizeof oper->oflags));
R_SAFE(read_data(fd, &oper->maxlogins, sizeof oper->maxlogins));
R_SAFE(read_data(fd, &fromcount, sizeof fromcount));
for (j = 1; j <= fromcount; j++)
{
from = NewFrom;
RF_SAFE(read_str(fd, &from->name));
AddListItem(from, oper->from);
}
if (Find_oper(oper->name))
{
char *oldname = oper->name;
config_status("Dikkat: Hesap Bloke Edildi. Hesap: '%s', "
"Zaten Boyle bi hesap bulunmakta. Hesap: '_%s'",
oldname, oldname);
oper->name = (char *) MyMallocEx(strlen(oldname) + 2);
*oper->name = '_';
strcat(oper->name, oldname);
MyFree(oldname);
}
AddListItem(oper, conf_oper);
AddExternalOper(oper);
}
close(fd);
return 0;
}
// =========================================================================
/*
* Auth_CheckError2:
* makes sure password and authtype are valid
*/
static int Auth_CheckError2(aClient *sptr, char *password, short type)
{
#ifdef AUTHENABLE_SSL_CLIENTCERT
X509 *x509_filecert = NULL;
FILE *x509_f = NULL;
#endif
switch (type)
{
#ifdef AUTHENABLE_UNIXCRYPT
case AUTHTYPE_UNIXCRYPT:
/* If our data is like 1 or none, we just let em through .. */
if (strlen(password) < 2)
{
sendnotice(sptr, "*** AUTHTYPE_UNIXCRYPT: no salt (crypt strings will always be >2 in length)");
return 0;
}
break;
#endif
#ifdef AUTHENABLE_SSL_CLIENTCERT
case AUTHTYPE_SSL_CLIENTCERT:
if (!(x509_f = fopen(password, "r")))
{
sendnotice(sptr, "*** AUTHTYPE_SSL_CLIENTCERT: error opening file %s",
password);
return 0;
}
x509_filecert = PEM_read_X509(x509_f, NULL, NULL, NULL);
fclose(x509_f);
if (!x509_filecert)
{
sendnotice(sptr, "*** AUTHTYPE_SSL_CLIENTCERT: PEM_read_X509 errored in file %s (format error?)",
password);
return 0;
}
X509_free(x509_filecert);
break;
#endif
default: ;
}
return 1;
}
/*
* Auth_Convert2:
* converts password and authtype to anAuthStruct
*/
static anAuthStruct *Auth_Convert2(char *password, short type)
{
anAuthStruct *as;
as = (anAuthStruct *) MyMalloc(sizeof(anAuthStruct));
as->data = strdup(password);
as->type = type;
return as;
}
/*
* Auth_FindName:
* finds an authentication method name (used by /confoper)
*/
static char *Auth_FindName(short type)
{
anAuthStruct *p;
for (p = AuthTypes; p->data; p++)
if (p->type == type)
break;
return p->data;
}
static anAuthStruct *Auth_DoAll(aClient *sptr, char *password, char *authtype)
{
short type;
char *encpass = NULL;
if ((type = Auth_FindType(authtype)) == -1)
{
sendnotice(sptr, "*** %s is not a supported authentication method",
authtype);
return NULL;
}
if (!Auth_CheckError2(sptr, password, type))
{
/* error message already sent */
return NULL;
}
if (type == AUTHTYPE_SSL_CLIENTCERT)
encpass = password;
else if (!(encpass = Auth_Make(type, password)))
{
sendnotice(sptr, "*** Authentication method %s failed", authtype);
return NULL;
}
return Auth_Convert2(encpass, type);
}
// =========================================================================
static unsigned parse_password(char **authtype, char **password)
{
char *p;
if ((p = strchr(*password, '@')))
{
if (p == *password || !p[1])
return 0;
*p = 0;
*authtype = *password;
*password = p+1;
}
else
*authtype = "plain";
return 1;
}
/*
* is_valid_mask:
* checks whether a mask is in a correct user@host form
* returns NULL on error, otherwise a pointer to '@'.
*/
static char *is_valid_mask(char *mask)
{
char *p, *mid;
/* '@' */
if (!*mask || (!(mid = strchr(mask, '@'))))
return NULL;
if (mid == mask || !mid[1])
return NULL;
/* username */
if (*mask != '~' && *mask != '*' && *mask != '?' && !isallowed(*mask))
return NULL;
for (p = mask + 1; p < mid; p++)
if (*p != '*' && *p != '?' && !isallowed(*p))
return NULL;
/* hostname */
for (p = mid + 1; *p; p++)
if ((*p != '*') && (*p != '?') && (*p != '_') && (*p != '-')
&& (*p != '.') && (*p != ':') && !isalnum(*p))
return NULL;
return mid;
}
/*
* check_all_masks:
* Checks all user@host masks for validity in a string separated by
* spaces. Returns the first bad mask, or NULL if all masks are valid.
*/
static char *check_all_masks(char *userhosts)
{
char *m, *p = NULL;
char *str = strdup(userhosts);
for (m = strtoken(&p, str, " "); m; m = strtoken(&p, NULL, " "))
if (!is_valid_mask(m))
{
strcpy(buf, m);
ircfree(str);
return buf;
}
ircfree(str);
return NULL;
}
static long convert_oflags(char *flags)
{
long oflags = 0;
char *m;
int *i, flag;
for (m = flags; *m; m++)
for (i = _OldOperFlags; (flag = *i); i += 2)
if (*m == (char)(*(i + 1)))
{
oflags |= flag;
break;
}
return oflags;
}
static void add_userhosts(ConfigItem_oper *oper, char *userhosts)
{
ConfigItem_oper_from *from;
char *str = strdup(userhosts);
char *tmp, *p = NULL;
for (tmp = strtoken(&p, str, " "); tmp; tmp = strtoken(&p, NULL, " "))
{
FromLoop(from, oper->from)
if (!strcmp(from->name, tmp))
break;
if (from)
continue;
from = NewFrom;
from->name = strdup(tmp);
AddListItem(from, oper->from);
}
ircfree(str);
}
static unsigned has_privileges(aClient *sptr, int remote)
{
if (!IsPerson(sptr))
return 0;
if (!MyConnect(sptr))
return 1;
if (opers_auth)
{
if (!IsAnOper(sptr) || !FindOperPass(sptr))
return 0;
}
else
{
if (!IsOper(sptr))
return 0;
if (!remote)
{
if (!IsAdmin(sptr))
return 0;
}
else
{
if (!IsNetAdmin(sptr))
return 0;
}
}
return 1;
}
static int check_target(aClient *cptr, aClient *sptr, char *command,
char *token, int global, int parc, char *parv[])
{
static char format[] = "%s %s %s %s %s %s %s %s";
int ret = 0;
/* parc > 1 */
format[(parc - 1) * 3 - 1] = 0;
if (global)
sendto_serv_butone_token(cptr, sptr->name, command, token,
format, parv[1], parv[2], parv[3], parv[4],
parv[5], parv[6], parv[7], parv[8]);
else
ret = hunt_server_token(cptr, sptr, command, token,
format, 1, parc, parv);
format[(parc - 1) * 3 - 1] = ' ';
return ret;
}
/*
** ADDOPER/ADDGOPER ADDROPER
** parv[0] = sender prefix sender prefix
** parv[1] = oper name server mask
** parv[2] = oper password oper name
** parv[3] = flags oper password
** parv[4] = class flags
** parv[5] = userhosts class
** parv[6] = userhosts
*/
static int add_oper(aClient *sptr, char *name, char *password, char *flags,
char *classname, char *userhosts)
{
ConfigItem_oper *oper = NULL;
ConfigItem_class *class = NULL;
anAuthStruct *auth;
char *p, *authtype;
if (Find_oper(name))
{
sendnotice(sptr, "*** Uyari: %s Zaten Oper Listesinde", name);
return 0;
}
if (!parse_password(&authtype, &password))
{
sendnotice(sptr, "*** Lütfen daha Degisik bi sifre bulunuz.");
return 0;
}
if (!(class = Find_class(classname)))
{
sendnotice(sptr, "*** Uyari: %s Nickli Oper Kullanilmiyor", classname);
return 0;
}
if (userhosts && (p = check_all_masks(userhosts)))
{
sendnotice(sptr, "*** Uyari: Sebeb: '%s' . Bu sebepten dolayı islem yapilamadi. ", p);
return 0;
}
if (!(auth = Auth_DoAll(sptr, password, authtype)))
return 0;
oper = MyMallocEx(sizeof(ConfigItem_oper));
oper->name = strdup(name);
oper->auth = auth;
oper->class = class;
oper->oflags = convert_oflags(flags);
add_userhosts(oper, userhosts ? userhosts : "*@*");
AddListItem(oper, conf_oper);
AddExternalOper(oper);
save_opers();
sendnotice(sptr, "*** %s oper listesine eklendi.", name);
ircsprintf(buf, "*** [%s] %s nickini oper listesine ekleyen %s (verdigi flag: %s, klas: %s, hostu: %s)",
me.name, name, sptr->name, flags, classname,
userhosts ? userhosts : "*@*");
sendto_snomask(SNO_EYES, "%s", buf);
sendto_serv_butone_token(NULL, me.name, MSG_SENDSNO, TOK_SENDSNO, "e :%s", buf);
return 1;
}
static CMD_FUNC(m_addoper)
{
if (!has_privileges(sptr, 0))
{
sendto_one(sptr, err_str(ERR_NOPRIVILEGES), me.name, parv[0]);
return 0;
}
if (IsNotParam(4))
{
sendnotice(sptr, "*** Kullanimi: /ekle <oper-nicki> <oper-sifresi> <flaglari> <klas> [:][<userhost masks>]");
sendnotice(sptr, "*** Alttaki Örnekleri Okuyunuz !!!");
sendnotice(sptr, "*** Ornek1: NetworkAdmin => /ekle OperNick 1234567 rDRhgwlcLkKbBnGAaNCzWHtZvqdXOoe^ clients");
sendnotice(sptr, "*** Ornek2: Services Admin => /ekle OperNick 1234567 OaorehwgcLkKbZtBnGzW^Hv clients");
sendnotice(sptr, "*** Ornek3: Server Admin => /ekle OperNick 1234567 OAorehwgcLkKbZtBnGzW^Hv clients");
sendnotice(sptr, "*** Ornek4: Co Admin => /ekle OperNick 1234567 OorehwgcLkKbZtBnGCzW^Hv clients");
sendnotice(sptr, "*** Ornek5: IRCop => /ekle OperNick 1234567 OorewgcLkKbZtBnGzW^Hv clients");
return 0;
}
add_oper(sptr, parv[1], parv[2], parv[3], parv[4],
IsParam(5) ? parv[5] : NULL);
return 0;
}
static CMD_FUNC(m_addroper)
{
if (!has_privileges(sptr, 1))
{
sendto_one(sptr, err_str(ERR_NOPRIVILEGES), me.name, parv[0]);
return 0;
}
if (IsNotParam(5))
{
sendnotice(sptr, "*** Usage: /addroper <servermask> <name> [<auth-type>@]<password> <flags> <class> [:][<userhost masks>]");
sendnotice(sptr, "*** Examples: /addroper irc.server.com newlogin newpass NDRztZWHv clients");
sendnotice(sptr, "*** /addroper server2.* newlogin crypt@newpass NDRztZWHv clients :*@host1.* *@host2.*");
return 0;
}
if (check_target(cptr, sptr, "ADDROPER", "ORA", 0, parc,
parv) == HUNTED_ISME)
{
add_oper(sptr, parv[2], parv[3], parv[4], parv[5],
IsParam(6) ? parv[6] : NULL);
}
return 0;
}
static CMD_FUNC(m_addgoper)
{
if (!has_privileges(sptr, 1))
{
sendto_one(sptr, err_str(ERR_NOPRIVILEGES), me.name, parv[0]);
return 0;
}
if (IsNotParam(4))
{
sendnotice(sptr, "*** Usage: /addgoper <name> [<auth-type>@]<password> <flags> <class> [:][<userhost masks>]");
sendnotice(sptr, "*** Examples: /addgoper newlogin newpass NDRztZWHv clients");
sendnotice(sptr, "*** /addgoper newlogin crypt@newpass NDRztZWHv clients :*@host1.* *@host2.*");
return 0;
}
check_target(cptr, sptr, "ADDGOPER", "OGA", 1, parc, parv);
add_oper(sptr, parv[1], parv[2], parv[3], parv[4],
IsParam(5) ? parv[5] : NULL);
return 0;
}
/*
** DELOPER/DELGOPER DELROPER
** parv[0] = sender prefix sender prefix
** parv[1] = oper name server mask
** parv[2] = oper name
*/
static int del_oper(aClient *sptr, char *login)
{
ConfigItem_oper *oper;
BlockList *extoper;
if (!(oper = Find_oper(login)))
{
sendnotice(sptr, "*** Oper %s does not exist", login);
return 0;
}
if (!(extoper = FindExternalOper(oper)))
{
sendnotice(sptr, "*** Oper %s is not present in the external O:Line database",
login);
return 0;
}
DelListItem(oper, conf_oper);
DelExternalOper(extoper);
free_oper(oper);
save_opers();
sendnotice(sptr, "*** %s in Operligi Silindi. ", login);
ircsprintf(buf, "*** [%s] %s nickinin operini silen kisi: %s", me.name, login, sptr->name);
sendto_snomask(SNO_EYES, "%s", buf);
sendto_serv_butone_token(NULL, me.name, MSG_SENDSNO, TOK_SENDSNO, "e :%s", buf);
return 0;
}
static CMD_FUNC(m_deloper)
{
if (!has_privileges(sptr, 0))
{
sendto_one(sptr, err_str(ERR_NOPRIVILEGES), me.name, parv[0]);
return 0;
}
if (IsNotParam(1))
{
sendnotice(sptr, "*** Kullanimi: /sil <oper-nicki>");
sendnotice(sptr, "*** Ornek: /sil Oper-Nick");
sendnotice(sptr, "*** şeklinde kişinin operini silebilirsiniz.");
return 0;
}
del_oper(sptr, parv[1]);
return 0;
}
static CMD_FUNC(m_delroper)
{
if (!has_privileges(sptr, 1))
{
sendto_one(sptr, err_str(ERR_NOPRIVILEGES), me.name, parv[0]);
return -1;
}
if (IsNotParam(2))
{
sendnotice(sptr, "*** Usage: /delroper <servermask> <name>");
return 0;
}
if (check_target(cptr, sptr, "DELROPER", "ORD", 0, parc,
parv) == HUNTED_ISME)
del_oper(sptr, parv[2]);
return 0;
}
static CMD_FUNC(m_delgoper)
{
if (!has_privileges(sptr, 1))
{
sendto_one(sptr, err_str(ERR_NOPRIVILEGES), me.name, parv[0]);
return -1;
}
if (IsNotParam(1))
{
sendnotice(sptr, "*** Usage: /delgoper <name>");
return 0;
}
check_target(cptr, sptr, "DELGOPER", "OGD", 1, parc, parv);
del_oper(sptr, parv[1]);
return 0;
}
/*
** MODOPER/MODGOPER MODROPER
** parv[0] = sender prefix sender prefix
** parv[1] = oper name server mask
** parv[2] = option oper name
** parv[3] = value option
** parv[4] = encryption type value
** parv[5] = encryption type
*/
#define CHECKVALUE \
if (!value) \
{ \
sendto_one(sptr, err_str(ERR_NEEDMOREPARAMS), \
me.name, sptr->name, cmd); \
return 0; \
}
static int mod_oper(aClient *sptr, char *cmd, char *name, char *option,
char *value, char *enctype)
{
ConfigItem_oper *oper;
OperFlag *of;
if (!(of = config_binary_flags_search(_OperFields, option, OF_TABLESIZE)))
{
sendnotice(sptr, "*** Invalid option %s", option);
return 0;
}
if (!(oper = Find_oper(name)))
{
sendnotice(sptr, "*** Oper %s does not exist", name);
return 0;
}
if (!FindExternalOper(oper))
{
sendnotice(sptr, "*** Oper %s is not present in the external O:Line database",
name);
return 0;
}
switch (of->flag)
{
/* name */
case OF_NAME:
{
CHECKVALUE
if (strchr(value, SPACE))
{
sendnotice(sptr, "*** Oper names may not contain spaces");
return 0;
}
if (Find_oper(value))
{
sendnotice(sptr, "*** Oper %s already exists", value);
return 0;
}
ircfree(oper->name);
oper->name = strdup(value);
ircsprintf(buf, "%s changed the name of oper %s to %s",
sptr->name, name, value);
break;
}
/* swhois */
case OF_SWHOIS:
{
ircfree(oper->swhois);
if (value)
{
oper->swhois = strdup(value);
ircsprintf(buf, "%s changed the SWHOIS information for oper %s to %s",
sptr->name, name, value);
}
else
ircsprintf(buf, "%s removed the SWHOIS information from oper %s",
sptr->name, name);
break;
}
/* maxlogins */
case OF_MAXLOGINS:
{
oper->maxlogins = (value ? atoi(value) : 0);
ircsprintf(buf, "%s changed the number of max logins for oper %s to %d",
sptr->name, name, oper->maxlogins);
break;
}
/* class */
case OF_CLASS:
{
ConfigItem_class *class;
CHECKVALUE
if (!(class = Find_class(value)))
{
sendnotice(sptr, "*** Unknown class %s",
value);
return 0;
}
oper->class = class;
ircsprintf(buf, "%s changed the connection class of %s to %s",
sptr->name, name, value);
break;
}
/* snomask */
case OF_SNOMASK:
{
if (value)
{
if (strchr(value, SPACE))
{
sendnotice(sptr, "*** Snomasks may not contain spaces");
return 0;
}
}
ircfree(oper->snomask);
if (value)
{
oper->snomask = strdup(value);
ircsprintf(buf, "%s changed the snomask of oper %s to %s",
sptr->name, name, value);
}
else
ircsprintf(buf, "%s cleared the snomask of oper %s",
sptr->name, name);
break;
}
/* userhost */
case OF_USERHOST:
{
unsigned add = 1;
ConfigItem_oper_from *from;
CHECKVALUE
if (strchr(value, SPACE))
{
sendnotice(sptr, "*** Userhosts may not contain spaces");
return 0;
}
if (*value == '-')
{
add = 0;
value++;
}
else if (*value == '+')
value++;
if (add && !is_valid_mask(value))
{
sendnotice(sptr, "*** Bad mask '%s'", value);
return 0;
}
FromLoop(from, oper->from)
if (!strcmp(from->name, value))
break;
if (add)
{
if (from)
{
sendnotice(sptr, "*** Mask %s already added",
value);
return 0;
}
from = NewFrom;
from->name = strdup(value);
AddListItem(from, oper->from);
ircsprintf(buf, "%s added userhost '%s' for oper %s",
sptr->name, value, name);
}
else /* del */
{
if (!from)
{
sendnotice(sptr, "*** Mask %s not found",
value);
return 0;
}
ircfree(from->name);
DelListItem(from, oper->from);
MyFree(from);
/* add mask *@* if oper->from is NULL */
if (!oper->from)
{
from = NewFrom;
from->name = strdup("*@*");
AddListItem(from, oper->from);
}
ircsprintf(buf, "%s removed userhost '%s' from oper %s",
sptr->name, value, name);
}
break;
}
/* flags */
case OF_FLAGS:
{
CHECKVALUE
oper->oflags = convert_oflags(value);
ircsprintf(buf, "%s changed the flags of oper %s to %s",
sptr->name, name, oflagstr(oper->oflags));
break;
}
/* password */
case OF_PASSWORD:
{
anAuthStruct *auth;
char *authtype;
CHECKVALUE
if (enctype)
{
authtype = value;
value = enctype;
}
else
authtype = "plain";
if (strchr(value, SPACE))
{
sendnotice(sptr, "*** Passwords may not contain spaces");
return 0;
}
if (!(auth = Auth_DoAll(sptr, value, authtype)))
return 0;
Auth_DeleteAuthStruct(oper->auth);
oper->auth = auth;
ircsprintf(buf, "%s set a new password for oper %s",
sptr->name, name);
break;
}
}
save_opers();
sendnotice(sptr, "*** Oper %s modified succesfully", name);
sendto_snomask(SNO_EYES, "*** [%s] %s", me.name, buf);
sendto_serv_butone_token(NULL, me.name, MSG_SENDSNO, TOK_SENDSNO,
"e :*** [%s] %s", me.name, buf);
return 0;
}
static CMD_FUNC(m_modoper)
{
if (!has_privileges(sptr, 0))
{
sendto_one(sptr, err_str(ERR_NOPRIVILEGES), me.name, parv[0]);
return 0;
}
if (IsNotParam(2))
{
sendnotice(sptr, "*** Usage: /modoper <name> name|class|flags <value>");
sendnotice(sptr, "*** /modoper <name> swhois|snomask|maxlogins [:][<value>]");
sendnotice(sptr, "*** /modoper <name> password [<auth method>] <password>");
sendnotice(sptr, "*** /modoper <name> userhost +|-<mask>");
sendnotice(sptr, "*** Examples: /modoper someone snomask cFfkejvGq");
sendnotice(sptr, "*** /modoper someone swhois :This is the new swhois info");
sendnotice(sptr, "*** /modoper someone password crypt newpass");
return 0;
}
mod_oper(sptr, "MODOPER", parv[1], parv[2],
IsParam(3) ? parv[3] : NULL,
IsParam(4) ? parv[4] : NULL);
return 0;
}
static CMD_FUNC(m_modroper)
{
if (!has_privileges(sptr, 1))
{
sendto_one(sptr, err_str(ERR_NOPRIVILEGES), me.name, parv[0]);
return 0;
}
if (IsNotParam(3))
{
sendnotice(sptr, "*** Usage: /modroper <servermask> <name> name|class|flags <value>");
sendnotice(sptr, "*** /modroper <servermask> <name> swhois|snomask|maxlogins [:][<value>]");
sendnotice(sptr, "*** /modroper <servermask> <name> password [<auth method>] <password>");
sendnotice(sptr, "*** /modroper <servermask> <name> userhost +|-<mask>");
sendnotice(sptr, "*** Examples: /modroper server2.* someone snomask cFfkejvGq");
sendnotice(sptr, "*** /modroper irc.* someone swhois :This is the new swhois info");
sendnotice(sptr, "*** /modroper server1.* someone password crypt newpass");
return 0;
}
if (check_target(cptr, sptr, "MODROPER", "ORM", 0, parc,
parv) == HUNTED_ISME)
{
mod_oper(sptr, "MODROPER", parv[2], parv[3],
IsParam(4) ? parv[4] : NULL,
IsParam(5) ? parv[5] : NULL);
}
return 0;
}
static CMD_FUNC(m_modgoper)
{
if (!has_privileges(sptr, 1))
{
sendto_one(sptr, err_str(ERR_NOPRIVILEGES), me.name, parv[0]);
return 0;
}
if (IsNotParam(2))
{
sendnotice(sptr, "*** Usage: /modgoper <name> name|class|flags <value>");
sendnotice(sptr, "*** /modgoper <name> swhois|snomask|maxlogins [:][<value>]");
sendnotice(sptr, "*** /modgoper <name> password [<auth method>] <password>");
sendnotice(sptr, "*** /modgoper <name> userhost +|-<mask>");
sendnotice(sptr, "*** Examples: /modgoper someone snomask cFfkejvGq");
sendnotice(sptr, "*** /modgoper someone swhois :This is the new swhois info");
sendnotice(sptr, "*** /modgoper someone password crypt newpass");
return 0;
}
check_target(cptr, sptr, "MODGOPER", "OGM", 1, parc, parv);
mod_oper(sptr, "MODGOPER", parv[1], parv[2],
IsParam(3) ? parv[3] : NULL,
IsParam(4) ? parv[4] : NULL);
return 0;
}
/*
** CONFOPER CONFROPER
** parv[0] = sender prefix sender prefix
** parv[1] = oper name server mask
** parv[2] = oper name
*/
#define MaxSize (sizeof(confstr) - strlen(confstr) - 1)
static int show_oper(aClient *sptr, char *login)
{
static char confstr[BUFSIZE+1], tmp[BUFSIZE+1];
ConfigItem_oper *oper;
ConfigItem_oper_from *from;
char *authtype;
if (!(oper = Find_oper(login)))
{
sendnotice(sptr, "*** Oper %s does not exist", login);
return 0;
}
memset(&confstr, 0, sizeof confstr);
memset(&tmp, 0, sizeof tmp);
snprintf(confstr, sizeof confstr, "oper %s { password \"%s\" { %s; }; flags %s; class %s; ",
oper->name, oper->auth->data,
(authtype = Auth_FindName(oper->auth->type)) ? authtype : "plain",
oflagstr(oper->oflags), oper->class->name);
strncat(confstr, "from { ", MaxSize);
FromLoop(from, oper->from)
{
snprintf(tmp, sizeof tmp, "userhost %s; ", from->name);
strncat(confstr, tmp, MaxSize);
}
strncat(confstr, "}; ", MaxSize);
if (oper->swhois)
{
snprintf(tmp, sizeof tmp, "swhois \"%s\"; ", oper->swhois);
strncat(confstr, tmp, MaxSize);
}
if (oper->snomask)
{
snprintf(tmp, sizeof tmp, "snomask %s; ", oper->snomask);
strncat(confstr, tmp, MaxSize);
}
if (oper->maxlogins)
{
snprintf(tmp, sizeof tmp, "maxlogins %d; ", oper->maxlogins);
strncat(confstr, tmp, MaxSize);
}
strncat(confstr, "};", MaxSize);
sendnotice(sptr, "*** %s", confstr);
return 0;
}
static CMD_FUNC(m_confoper)
{
if (!has_privileges(sptr, 0))
{
sendto_one(sptr, err_str(ERR_NOPRIVILEGES), me.name, parv[0]);
return 0;
}
if (IsNotParam(1))
{
sendnotice(sptr, "*** Usage: /confoper <name>");
return 0;
}
show_oper(sptr, parv[1]);
return 0;
}
static CMD_FUNC(m_confroper)
{
if (!has_privileges(sptr, 1))
{
sendto_one(sptr, err_str(ERR_NOPRIVILEGES), me.name, parv[0]);
return 0;
}
if (IsNotParam(2))
{
sendnotice(sptr, "*** Usage: /confroper <servermask> <name>");
return 0;
}
if (check_target(cptr, sptr, "CONFROPER", "ORC", 0, parc,
parv) == HUNTED_ISME)
show_oper(sptr, parv[2]);
return 0;
}
static int m_masterpass(aClient *cptr, aClient *sptr, int parc, char *parv[])
{
char *password;
if (!MyClient(sptr) || !IsPerson(sptr) || !IsAnOper(sptr))
{
sendto_one(sptr, err_str(ERR_NOPRIVILEGES),
me.name, sptr->name);
return 0;
}
password = IsParam(1) ? parv[1] : NULL;
if (!password)
{
sendnotice(sptr, "*** Usage: /masterpass <password>");
return 0;
}
if (!opers_auth)
{
sendnotice(sptr, "*** Password authentication is disabled");
return 0;
}
if (FindOperPass(sptr))
{
sendnotice(sptr, "*** You have already authenticated");
return 0;
}
if (Auth_Check(sptr, opers_auth, password) == -1)
{
sendto_one(sptr, err_str(ERR_PASSWDMISMATCH), me.name, sptr->name);
ircsprintf(buf, "*** [%s] %s tried to use /masterpass with a wrong password",
me.name, sptr->name);
sendto_snomask(SNO_EYES, "%s", buf);
sendto_serv_butone_token(NULL, me.name, MSG_SENDSNO, TOK_SENDSNO, "e :%s", buf);
return 0;
}
AddOperPass(sptr);
sendnotice(sptr, "*** Successful authentication");
ircsprintf(buf, "*** [%s] %s has passed the master password authentication",
me.name, sptr->name);
sendto_snomask(SNO_EYES, "%s", buf);
sendto_serv_butone_token(NULL, me.name, MSG_SENDSNO, TOK_SENDSNO, "e :%s", buf);
return 0;
}
|
