unsigned int cmd_connect(callbackp *callbacki)
{
USERS *nuser;
RAW *newraw;
json_item *jstr = NULL;
nuser = adduser(NULL, NULL, NULL, callbacki->call_user, callbacki->g_ape);
callbacki->call_user = nuser;
jstr = json_new_object();
json_set_property_objN(jstr, "user", 4, get_json_object_user(callbacki->call_user));
newraw = forge_raw("IDENT", jstr);
newraw->priority = RAW_PRI_HI;
post_raw_sub(newraw, callbacki->call_subuser, callbacki->g_ape);
jstr = json_new_object();
json_set_property_strN(jstr, "sessid", 6, nuser->sessid, 32);
newraw = forge_raw(RAW_LOGIN, jstr);
newraw->priority = RAW_PRI_HI;
post_raw(newraw, nuser, callbacki->g_ape);
return (RETURN_NOTHING);
}
int
main(int argc, char **argv)
{
int index;
grad_app_setup();
if (grad_argp_parse(&argp, &argc, &argv, 0, &index, NULL))
return 1;
argv += index;
argc -= index;
if (argc) {
setlinebuf(stdout);
for (; *argv; ++argv)
adduser(*argv);
}
grad_dict_init();
read_naslist();
if (nas_name) {
grad_nas_t *nas = grad_nas_lookup_name(nas_name);
if (!nas) {
if (grad_ip_getnetaddr(nas_name, &nas_ip)) {
grad_log(GRAD_LOG_ERR, "unknown nas: %s", nas_name);
return 1;
}
}
}
radwtmp();
return 0;
}
void cmd_adduser(void) {
Ceo__AddUser *in_proto;
Ceo__AddUserResponse *out_proto = response_create();
struct strbuf in = STRBUF_INIT;
struct strbuf out = STRBUF_INIT;
if (strbuf_read(&in, STDIN_FILENO, 0) < 0)
fatalpe("read");
in_proto = ceo__add_user__unpack(&protobuf_c_default_allocator,
in.len, (uint8_t *)in.buf);
if (!in_proto)
fatal("malformed add user message");
char *client = getenv("CEO_USER");
if (!client)
fatal("environment variable CEO_USER is not set");
adduser(in_proto, out_proto, client);
strbuf_grow(&out, ceo__add_user_response__get_packed_size(out_proto));
strbuf_setlen(&out, ceo__add_user_response__pack(out_proto, (uint8_t *)out.buf));
if (full_write(STDOUT_FILENO, out.buf, out.len))
fatalpe("write: stdout");
ceo__add_user__free_unpacked(in_proto, &protobuf_c_default_allocator);
response_delete(out_proto);
strbuf_release(&in);
strbuf_release(&out);
}
void processMsg(int sockfd, struct sockaddr_in addr, struct chatmsg msg) {
if (msg.msgtype == CHATMSG_JOIN) {
adduser(addr, msg.userid);
} else if (msg.msgtype == CHATMSG_CHAT) {
sendtouser(sockfd, msg);
} else if (msg.msgtype == CHATMSG_HEART) {
islive[msg.userid] = time(NULL);
}
}
void Shop::testData(std::string fileName)
{
auto& reader = FileReader::instance();
reader.readFile(fileName, 1);
auto rawFile = reader.returnRawDatabse();
auto itrBegin = rawFile.begin();
auto itrEnd = rawFile.end();
auto itr = itrBegin;
size_t i = 0;
std::string value;
unsigned int index = 0;
while (itr != itrEnd)
{
std::string line = *itr;
auto pos = line.find(',');
std::string title = line.substr(0, pos);
line = line.substr(++pos);
bool doneReading = false;
while (!doneReading)
{
if (pos == std::string::npos)
{
doneReading = true;
}
std::string val = line.substr(0, pos);
if (val.compare("?") != -1)
{
val = "0";
}
std::stringstream ss;
ss.str(val);
float rating;
ss >> rating;
auto reviewer = UserFactory::instance().getUser(title);
reviewer->addRating(movienames[index], rating);
auto movieEntity = CommodityFactory::instance().getUser(movienames[index]);
movieEntity->adduser(reviewer, rating);
line = line.substr(pos + 1);
pos = line.find(',');
index++;
}
++itr;
index = 0;
}
reader.clear();
}
static User*
uid2user(int id)
{
User *u;
struct passwd *p;
for(u=utab[id%nelem(utab)]; u; u=u->next)
if(u->id == id)
return u;
if((p = getpwuid(id)) == nil)
return nil;
return adduser(p);
}
/* Deprecated */
unsigned int cmd_pconnect(callbackp *callbacki)
{
USERS *nuser;
nuser = adduser(callbacki->fdclient, callbacki->host, callbacki->g_ape);
if (nuser == NULL) {
SENDH(callbacki->fdclient, ERR_CONNECT, callbacki->g_ape);
return (FOR_NOTHING);
}
nuser->flags |= FLG_PCONNECT;
return (FOR_LOGIN | FOR_UPDATE_IP);
}
void setup_HQ(int n) {
dcc[n].addr = iptolong(getmyip());
dcc[n].sock = STDOUT;
dcc[n].timeval = now;
dcc[n].u.chat->con_flags = conmask | LOG_ALL;
dcc[n].u.chat->strip_flags = STRIP_ALL;
dcc[n].status = STAT_ECHO;
strlcpy(dcc[n].nick, STR("HQ"), sizeof(dcc[n].nick));
strlcpy(dcc[n].host, STR("llama@console"), sizeof(dcc[n].host));
dcc[n].user = get_user_by_handle(userlist, dcc[n].nick);
/* Make sure there's an innocuous HQ user if needed */
if (!dcc[n].user) {
userlist = adduser(userlist, dcc[n].nick, "none", "-", USER_ADMIN | USER_OWNER | USER_MASTER | USER_VOICE | USER_OP | USER_PARTY | USER_CHUBA | USER_HUBA, 0);
dcc[n].user = get_user_by_handle(userlist, dcc[n].nick);
}
}
static User*
uname2user(char *name)
{
int i;
User *u;
struct passwd *p;
for(i=0; i<nelem(utab); i++)
for(u=utab[i]; u; u=u->next)
if(strcmp(u->name, name) == 0)
return u;
if((p = getpwnam(name)) == nil)
return nil;
return adduser(p);
}
static struct userrec* add_bot_userlist(char* bot) {
struct userrec *u = NULL;
if (!(u = get_user_by_handle(userlist, bot))) {
/* I need to be on the userlist... doh. */
userlist = adduser(userlist, bot, "none", "-", USER_OP, 1);
u = get_user_by_handle(userlist, bot);
struct bot_addr *bi = (struct bot_addr *) my_calloc(1, sizeof(struct bot_addr));
bi->uplink = (char *) my_calloc(1, 1);
bi->address = (char *) my_calloc(1, 1);
bi->telnet_port = 3333;
bi->relay_port = 3333;
bi->hublevel = 999;
set_user(&USERENTRY_BOTADDR, u, bi);
}
return u;
}
static User*
uid2user(int id)
{
User *u;
struct passwd pwd, *result;
char buf[512];
for(u=utab[id%nelem(utab)]; u; u=u->next)
if(u->id == id)
return u;
getpwuid_r(id, &pwd, buf, sizeof(buf), &result);
if(result == NULL)
return nil;
return adduser(result);
}
int runCommand(){
int i = 0;
int argc = splitString(textBuffer, ' ');
for(i =0;i<argc;i++){argv[i]=stringArray[i];}
if(k_strcmp(argv[0], "")==0){}
else if(k_strcmp(argv[0], "clear")==0){ clearScreen(); typeOffset = 0;}
else if(k_strcmp(argv[0], "history")==0){ printHistory();}
else if(k_strcmp(argv[0], "pong")==0){ pong();}
else if(k_strcmp(argv[0], "help")==0){ listCommands();}
else if(k_strcmp(argv[0], "welcome")==0){ welcome();}
else if(k_strcmp(argv[0], "splash")==0){ splash();}
else if(k_strcmp(argv[0], "ls")==0){ ls(argc, argv); }
else if(k_strcmp(argv[0], "cat")==0){ cat(argc, argv); }
else if(k_strcmp(argv[0], "rm")==0){ rm(argc, argv); }
else if(k_strcmp(argv[0], "chmod")==0){ chmod(argc, argv); }
else if(k_strcmp(argv[0], "te")==0){ te(argc, argv); }
else if(k_strcmp(argv[0], "cp")==0){ cp(argc, argv); }
else if(k_strcmp(argv[0], "diff")==0){ diff(argc, argv); }
else if(k_strcmp(argv[0], "wc")==0){ wc(argc, argv); }
else if(k_strcmp(argv[0], "su")==0){ su(argc, argv); }
else if(k_strcmp(argv[0], "chown")==0){ chown(argc, argv); }
else if(k_strcmp(argv[0], "echo")==0){ echo(argc, argv); }
else if(k_strcmp(argv[0], "adduser")==0){ adduser(argc, argv); }
else if(k_strcmp(argv[0], "deluser")==0){ deluser(argc, argv); }
else if(k_strcmp(argv[0], "listus")==0){ listus(); }
else if(k_strcmp(argv[0], "passwd")==0){ passwd(argc, argv); }
else if(k_strcmp(argv[0], "mkdir")==0){ mkdir(argc, argv); }
else if(k_strcmp(argv[0], "rmdir")==0){ rmdir(argc, argv); }
else if(k_strcmp(argv[0], "cd")==0){ cd(argc, argv); }
else if(k_strcmp(argv[0], "pwd")==0){ pwd(argc, argv); }
else if(k_strcmp(argv[0], "mv")==0){ mv(argc, argv); }
// else check files
else {
printToConsole("Error: Unknown command '");
printToConsole(argv[0]);
printToConsole("'\n");
}
return 0;
}
static User*
uname2user(char *name)
{
int i;
User *u;
struct passwd pwd, *result;
char buf[512];
for(i=0; i<nelem(utab); i++)
for(u=utab[i]; u; u=u->next)
if(strcmp(u->name, name) == 0)
return u;
getpwnam_r(name, &pwd, buf, sizeof(buf), &result);
if(result == NULL)
return nil;
return adduser(result);
}
int main(int argc, char *argv[]) {
adduser();
showusers(argc, argv);
show_bill();
fcloseall();
lightbill obj;
obj = find_bill(1 );
if(obj.id) {
printf("\n\n");
printf("%d\n\n", obj.prev_unit);
}
generate_bill(2, 250);
show_bill();
user h;
h = finduser(1);
remove_user(5);
printf("%s", h.id);
return 0;
}
int usermgrmain(void)
{
curs_set(0);
while(true)
{
drawtui(); // Call Draw TUI (Text User Interface)
listusers();
do
{
usrkey=getch();
switch(usrkey)
{
case KEY_F(1):
usermgrhelp();
break;
case KEY_F(4):
adduser();
break;
case KEY_F(9):
executedefaultshell();
break;
case KEY_F(10):
return 0;
break;
}
drawtui(); // Call Draw TUI (Text User Interface)
listusers();
} while (usrkey != '\n');
/* Stuff to go here */
};
wgetch(userlistbox); // Wait for response in a Window
endwin(); // End Curses Sessions
return 0;
}
unsigned int cmd_connect(callbackp *callbacki)
{
USERS *nuser;
RAW *newraw;
struct json *jstr = NULL;
nuser = adduser(callbacki->fdclient, callbacki->host, callbacki->g_ape);
callbacki->call_user = nuser;
if (nuser == NULL) {
SENDH(callbacki->fdclient, ERR_CONNECT, callbacki->g_ape);
return (FOR_NOTHING);
}
if (strcmp(callbacki->param[1], "2") == 0) {
nuser->transport = TRANSPORT_IFRAME;
nuser->flags |= FLG_PCONNECT;
} else {
nuser->transport = TRANSPORT_LONGPOLLING;
}
subuser_restor(getsubuser(callbacki->call_user, callbacki->host), callbacki->g_ape);
set_json("sessid", nuser->sessid, &jstr);
newraw = forge_raw(RAW_LOGIN, jstr);
newraw->priority = 1;
post_raw(newraw, nuser, callbacki->g_ape);
return (FOR_LOGIN | FOR_UPDATE_IP);
}
void cmd_Up(char str[10],char strname[14])
{
int l,i,itemp;
char *a;
l=strlen(strname);
if(l>=14)
{
printf("文件名过长!\n");
return;
}
if(strcmp(str,"cd")==0)
{
if(Enterdir(strname)>=0)
{
l=strlen(cmdhead);
// printf("进入目录成功!\n");
if(strcmp(strname,"..")==0)
{
if(strcmp(cmdhead,"root")!=0)
{
i=0;
while(cmdhead[i]!='\0')
{
if(cmdhead[i]=='\\')
{
itemp=i;
}
i++;
}
cmdhead[itemp]='\0';
}
}
else if(strcmp(strname,".")!=0)
{
strcat(cmdhead,"\\");
strcat(cmdhead,strname);
}
}
else
{
printf("进入目录失败!\n");
}
}
else if(strcmp(str,"create")==0)
{
if(create(strname))
{
// printf("文件创建成功!\n");
}
else
{
printf("文件创建失败!\n");
}
}
else if(strcmp(str,"read")==0)
{
char * buf;
buf=ReadFile(strname);
if(buf==NULL)
{
printf("读取失败!\n");
}
else
{
printf("所读文件内容：\n%s\n",buf);
}
free(buf);
}
else if(strcmp(str,"cdir")==0)
{
if(cdir(strname))
{
// printf("文件夹创建成功!\n");
}
else
{
printf("文件夹创建失败!\n");
}
}
else if(strcmp(str,"adduser")==0)
{
if(adduser(strname))
{
// printf("文件夹创建成功!\n");
}
else
{
printf("用户创建失败!\n");
}
}
else if(strcmp(str,"del")==0)
{
if(deletefd(strname))
{
// printf("%s成功删除!\n",strname);
}
else
{
printf("%s删除失败!\n",strname);
}
}
else if(strcmp(str,"write")==0)
{
if(mywrite(strname))
{
printf("%s保存成功!\n",strname);
}
else
{
printf("%s保存失败!\n",strname);
}
}
else
{
printf("错误命令!\n");
}
}
/*
* adduser will take a login_name as its first parameter.
*
* home
* shell
* gecos
*
* can be customized via command-line parameters.
* ________________________________________________________________________ */
int adduser_main(int argc, char **argv)
{
struct passwd pw;
const char *login;
const char *gecos = default_gecos;
const char *home = NULL;
const char *shell = DEFAULT_SHELL;
const char *usegroup = NULL;
int flags;
int setpass = 1;
int makehome = 1;
/* init */
if (argc < 2) {
bb_show_usage();
}
/* get args */
flags = bb_getopt_ulflags(argc, argv, "h:g:s:G:DSH", &home, &gecos, &shell, &usegroup);
if (flags & SETPASS) {
setpass = 0;
}
if (flags & MAKEHOME) {
makehome = 0;
}
/* got root? */
if_i_am_not_root();
/* get login */
if (optind >= argc) {
bb_error_msg_and_die( "no user specified");
}
login = argv[optind];
/* create string for $HOME if not specified already */
if (!home) {
home = concat_path_file(default_home_prefix, login);
}
#ifdef CONFIG_FEATURE_SHADOWPASSWDS
/* is /etc/shadow in use? */
shadow_enabled = (0 == access(bb_path_shadow_file, F_OK));
#endif
/* create a passwd struct */
pw.pw_name = (char *)login;
pw.pw_passwd = (char *)default_passwd;
pw.pw_uid = 0;
pw.pw_gid = 0;
pw.pw_gecos = (char *)gecos;
pw.pw_dir = (char *)home;
pw.pw_shell = (char *)shell;
if (usegroup) {
/* Add user to a group that already exists */
pw.pw_gid = bb_xgetgrnam(usegroup);
/* exits on error */
}
/* grand finale */
return adduser(bb_path_passwd_file, &pw, makehome, setpass);
}
void
cmd_newuser(void)
{
char user[NAMELEN], param[NAMELEN], msg[100];
int i, c;
/*
* get uid
*/
cname(user);
cname(param);
for(i=0; i<NAMELEN; i++) {
c = user[i];
if(c == 0)
break;
if(c >= '0' && c <= '9'
|| c >= 'a' && c <= 'z'
|| c >= 'A' && c <= 'Z')
continue;
cprint("bad character in name: 0x%x\n", c);
return;
}
if(i < 2) {
cprint("name too short: %s\n", user);
return;
}
if(i >= NAMELEN) {
cprint("name too long: %s\n", user);
return;
}
switch(param[0]){
case 0:
if(!adduser(user, 0))
return;
cmd_exec("user");
break;
case ':':
adduser(user, 1);
cmd_exec("user");
return;
case '#':
adduser(user, 0);
cmd_exec("user");
return;
}
/*
* create directories
*/
cmd_exec("user");
sprint(msg, "create /usr/%s %s %s 775 d", user, user, user);
cmd_exec(msg);
sprint(msg, "create /usr/%s/tmp %s %s 775 d", user, user, user);
cmd_exec(msg);
sprint(msg, "create /usr/%s/lib %s %s 775 d", user, user, user);
cmd_exec(msg);
sprint(msg, "create /usr/%s/bin %s %s 775 d", user, user, user);
cmd_exec(msg);
sprint(msg, "create /usr/%s/bin/rc %s %s 775 d", user, user, user);
cmd_exec(msg);
sprint(msg, "create /usr/%s/bin/mips %s %s 775 d", user, user, user);
cmd_exec(msg);
sprint(msg, "create /usr/%s/bin/386 %s %s 775 d", user, user, user);
cmd_exec(msg);
sprint(msg, "create /usr/%s/bin/power %s %s 775 d", user, user, user);
cmd_exec(msg);
sprint(msg, "create /usr/%s/bin/alpha %s %s 775 d", user, user, user);
cmd_exec(msg);
}
void ServerNetworkHandler::inMessage(std::string pMessage, int pSocket){
pMessage = Tokenizer::cleanEntry(pMessage);
std::string command = Tokenizer::getCommandSpace(pMessage, 1);
if (_sessionID == -1 && command != "connect" && command != "adduser"){
outMessage("?Error: No se ha inciado sesión\n", pSocket);
} else {
std::string param = Tokenizer::getParameters(pMessage);
std::cout<<param<<std::endl;
if (command == "get"){
get(param, pSocket);
} else if (command == "cd"){
cd(param, pSocket);
} else if (command == "rm"){
rm(param, pSocket);
} else if (command == "touch"){
touch(param, pSocket);
} else if (command == "connect"){
connect(param, pSocket);
} else if (command == "mkdir"){
mkdir(param, pSocket);
} else if (command == "adduser"){
adduser(param, pSocket);
} else if (command == "openfile"){
openfile(param, pSocket);
} else if (command == "appendReg"){
appendReg(param, pSocket);
} else if (command == "delReg"){
if (param == ""){
delActualReg(pSocket);
} else {
delReg(param, pSocket);
}
} else if (command == "write"){
write(param, pSocket);
} else if (command == "seek"){
seek(param, pSocket);
} else if (command == "addReg"){
addReg(param, pSocket);
} else if (command == "read"){
if (param == ""){
readActual(pSocket);
} else {
readRegister(param, pSocket);
}
} else if (command == "close"){
close(pSocket);
} else if (command == "consoleMode"){
consoleMode(param, pSocket);
} else {
outMessage("?Error: No se ha encontrado la instrucción " + command + '\n', pSocket);
}
consoleUI(pSocket);
}
}
int main(int arg_c, char **arg_v)
{
int i, xx;
char s[25];
FILE *f;
struct sigaction sv;
struct chanset_t *chan;
#ifdef DEBUG
struct rlimit cdlim;
#endif
#ifdef STOP_UAC
int nvpair[2];
#endif
/* Make sure it can write core, if you make debug. Else it's pretty
* useless (dw)
*
* Only allow unlimited size core files when compiled with DEBUG defined.
* This is not a good idea for normal builds -- in these cases, use the
* default system resource limits instead.
*/
#ifdef DEBUG
cdlim.rlim_cur = RLIM_INFINITY;
cdlim.rlim_max = RLIM_INFINITY;
setrlimit(RLIMIT_CORE, &cdlim);
#endif
#ifdef DEBUG_CONTEXT
/* Initialise context list */
for (i = 0; i < 16; i++)
Context;
#endif
/* Include patch.h header for patch("...") */
#include "patch.h"
argc = arg_c;
argv = arg_v;
/* Version info! */
egg_snprintf(ver, sizeof ver, "eggdrop v%s", egg_version);
egg_snprintf(version, sizeof version,
"Eggdrop v%s (C) 1997 Robey Pointer (C) 2010 Eggheads",
egg_version);
/* Now add on the patchlevel (for Tcl) */
sprintf(&egg_version[strlen(egg_version)], " %u", egg_numver);
strcat(egg_version, egg_xtra);
/* For OSF/1 */
#ifdef STOP_UAC
/* Don't print "unaligned access fixup" warning to the user */
nvpair[0] = SSIN_UACPROC;
nvpair[1] = UAC_NOPRINT;
setsysinfo(SSI_NVPAIRS, (char *) nvpair, 1, NULL, 0);
#endif
/* Set up error traps: */
sv.sa_handler = got_bus;
sigemptyset(&sv.sa_mask);
#ifdef SA_RESETHAND
sv.sa_flags = SA_RESETHAND;
#else
sv.sa_flags = 0;
#endif
sigaction(SIGBUS, &sv, NULL);
sv.sa_handler = got_segv;
sigaction(SIGSEGV, &sv, NULL);
#ifdef SA_RESETHAND
sv.sa_flags = 0;
#endif
sv.sa_handler = got_fpe;
sigaction(SIGFPE, &sv, NULL);
sv.sa_handler = got_term;
sigaction(SIGTERM, &sv, NULL);
sv.sa_handler = got_hup;
sigaction(SIGHUP, &sv, NULL);
sv.sa_handler = got_quit;
sigaction(SIGQUIT, &sv, NULL);
sv.sa_handler = SIG_IGN;
sigaction(SIGPIPE, &sv, NULL);
sv.sa_handler = got_ill;
sigaction(SIGILL, &sv, NULL);
sv.sa_handler = got_alarm;
sigaction(SIGALRM, &sv, NULL);
/* Initialize variables and stuff */
now = time(NULL);
chanset = NULL;
egg_memcpy(&nowtm, localtime(&now), sizeof(struct tm));
lastmin = nowtm.tm_min;
srandom((unsigned int) (now % (getpid() + getppid())));
init_mem();
init_language(1);
if (argc > 1)
for (i = 1; i < argc; i++)
do_arg(argv[i]);
printf("\n%s\n", version);
#ifndef CYGWIN_HACKS
/* Don't allow eggdrop to run as root
* This check isn't useful under cygwin and has been
* reported to cause trouble in some situations.
*/
if (((int) getuid() == 0) || ((int) geteuid() == 0))
fatal("ERROR: Eggdrop will not run as root!", 0);
#endif
#ifndef REPLACE_NOTIFIER
init_threaddata(1);
#endif
init_userent();
init_misc();
init_bots();
init_modules();
if (backgrd)
bg_prepare_split();
init_tcl(argc, argv);
init_language(0);
#ifdef STATIC
link_statics();
#endif
strncpyz(s, ctime(&now), sizeof s);
strcpy(&s[11], &s[20]);
putlog(LOG_ALL, "*", "--- Loading %s (%s)", ver, s);
chanprog();
if (!encrypt_pass) {
printf(MOD_NOCRYPT);
bg_send_quit(BG_ABORT);
exit(1);
}
i = 0;
for (chan = chanset; chan; chan = chan->next)
i++;
putlog(LOG_MISC, "*", "=== %s: %d channels, %d users.",
botnetnick, i, count_users(userlist));
#ifdef TLS
ssl_init();
#endif
cache_miss = 0;
cache_hit = 0;
if (!pid_file[0])
egg_snprintf(pid_file, sizeof pid_file, "pid.%s", botnetnick);
/* Check for pre-existing eggdrop! */
f = fopen(pid_file, "r");
if (f != NULL) {
fgets(s, 10, f);
xx = atoi(s);
i = kill(xx, SIGCHLD); /* Meaningless kill to determine if pid
* is used */
if (i == 0 || errno != ESRCH) {
printf(EGG_RUNNING1, botnetnick);
printf(EGG_RUNNING2, pid_file);
bg_send_quit(BG_ABORT);
exit(1);
}
}
/* Move into background? */
if (backgrd) {
bg_do_split();
} else { /* !backgrd */
xx = getpid();
if (xx != 0) {
FILE *fp;
/* Write pid to file */
unlink(pid_file);
fp = fopen(pid_file, "w");
if (fp != NULL) {
fprintf(fp, "%u\n", xx);
if (fflush(fp)) {
/* Let the bot live since this doesn't appear to be a botchk */
printf(EGG_NOWRITE, pid_file);
fclose(fp);
unlink(pid_file);
} else
fclose(fp);
} else
printf(EGG_NOWRITE, pid_file);
}
}
use_stderr = 0; /* Stop writing to stderr now */
if (backgrd) {
/* Ok, try to disassociate from controlling terminal (finger cross) */
#ifdef HAVE_SETPGID
setpgid(0, 0);
#endif
/* Tcl wants the stdin, stdout and stderr file handles kept open. */
freopen("/dev/null", "r", stdin);
freopen("/dev/null", "w", stdout);
freopen("/dev/null", "w", stderr);
#ifdef CYGWIN_HACKS
FreeConsole();
#endif
}
/* Terminal emulating dcc chat */
if (!backgrd && term_z) {
int n = new_dcc(&DCC_CHAT, sizeof(struct chat_info));
getvhost(&dcc[n].sockname, AF_INET);
dcc[n].sock = STDOUT;
dcc[n].timeval = now;
dcc[n].u.chat->con_flags = conmask;
dcc[n].u.chat->strip_flags = STRIP_ALL;
dcc[n].status = STAT_ECHO;
strcpy(dcc[n].nick, "HQ");
strcpy(dcc[n].host, "llama@console");
/* HACK: Workaround not to pass literal "HQ" as a non-const arg */
dcc[n].user = get_user_by_handle(userlist, dcc[n].nick);
/* Make sure there's an innocuous HQ user if needed */
if (!dcc[n].user) {
userlist = adduser(userlist, dcc[n].nick, "none", "-", USER_PARTY);
dcc[n].user = get_user_by_handle(userlist, dcc[n].nick);
}
setsock(STDOUT, 0); /* Entry in net table */
dprintf(n, "\n### ENTERING DCC CHAT SIMULATION ###\n\n");
dcc_chatter(n);
}
then = now;
online_since = now;
autolink_cycle(NULL); /* Hurry and connect to tandem bots */
add_help_reference("cmds1.help");
add_help_reference("cmds2.help");
add_help_reference("core.help");
add_hook(HOOK_SECONDLY, (Function) core_secondly);
add_hook(HOOK_MINUTELY, (Function) core_minutely);
add_hook(HOOK_HOURLY, (Function) core_hourly);
add_hook(HOOK_REHASH, (Function) event_rehash);
add_hook(HOOK_PRE_REHASH, (Function) event_prerehash);
add_hook(HOOK_USERFILE, (Function) event_save);
add_hook(HOOK_BACKUP, (Function) backup_userfile);
add_hook(HOOK_DAILY, (Function) event_logfile);
add_hook(HOOK_DAILY, (Function) event_resettraffic);
add_hook(HOOK_LOADED, (Function) event_loaded);
call_hook(HOOK_LOADED);
debug0("main: entering loop");
while (1) {
mainloop(1);
}
}
addusernow()
{
char pw[50];
int cnt=0, num;
char *c_num;
char **mailingListNames;
char *tmp;
char *email;
char **arguments;
int pid;
int i;
int error;
struct vqpasswd *mypw;
c_num = malloc(MAX_BUFF);
email = malloc(128);
tmp = malloc(MAX_BUFF);
arguments = (char **)malloc(MAX_BUFF);
count_users();
load_limits();
if ( AdminType!=DOMAIN_ADMIN ) {
sprintf(StatusMessage,"%s", get_html_text("142"));
vclose();
exit(0);
}
if ( MaxPopAccounts != -1 && CurPopAccounts >= MaxPopAccounts ) {
sprintf(StatusMessage, "%s %d\n", get_html_text("199"),
MaxPopAccounts);
show_menu();
vclose();
exit(0);
}
GetValue(TmpCGI,Newu, "newu=", MAX_BUFF);
if ( fixup_local_name(Newu) ) {
sprintf(StatusMessage, "%s %s\n", get_html_text("148"), Newu);
adduser();
vclose();
exit(0);
}
if ( check_local_user(Newu) ) {
sprintf(StatusMessage, "%s %s\n", get_html_text("175"), Newu);
adduser();
vclose();
exit(0);
}
GetValue(TmpCGI,Password1, "password1=", MAX_BUFF);
GetValue(TmpCGI,Password2, "password2=", MAX_BUFF);
if ( strncmp( Password1, Password2, MAX_BUFF ) != 0 ) {
sprintf(StatusMessage, "%s\n", get_html_text("200"));
adduser();
vclose();
exit(0);
}
if ( strlen(Password1) <= 0 ) {
sprintf(StatusMessage, "%s\n", get_html_text("234"));
adduser();
vclose();
exit(0);
}
strcpy(email, "");
strcat(email,Newu);
strcat(email,"@");
strcat(email,Domain);
GetValue(TmpCGI,Gecos, "gecos=", MAX_BUFF);
if ( strlen( Gecos ) == 0 ) {
strcpy(Gecos, Newu);
}
GetValue(TmpCGI, c_num, "number_of_mailinglist=", MAX_BUFF);
num = atoi(c_num);
if(!(mailingListNames = malloc(sizeof(char *) * num))) {
sprintf(StatusMessage, "%s\n", get_html_text("201"));
vclose();
exit(0);
} else {
for(cnt = 0; cnt < num; cnt++) {
if(!(mailingListNames[cnt] = malloc(MAX_BUFF))) {
sprintf(StatusMessage, "%s\n", get_html_text("201"));
vclose();
exit(0);
}
}
for(cnt = 0; cnt < num; cnt++) {
sprintf(tmp, "subscribe%d=", cnt);
error = GetValue(TmpCGI, mailingListNames[cnt], tmp, MAX_BUFF);
if( error != -1 ) {
pid=fork();
if (pid==0) {
sprintf(TmpBuf1, "%s/ezmlm-sub", EZMLMDIR);
sprintf(TmpBuf2, "%s/%s", RealDir, mailingListNames[cnt]);
execl(TmpBuf1, "ezmlm-sub", TmpBuf2, email, NULL);
exit(127);
} else {
wait(&pid);
}
}
}
}
/* add the user then get the vpopmail password structure */
if ( vadduser( Newu, Domain, Password1, Gecos, USE_POP ) == 0 &&
#ifdef MYSQL_REPLICATION
!sleep(2) &&
#endif
(mypw = vauth_getpw( Newu, Domain )) != NULL ) {
/* from the load_limits() function, set user flags */
if( DisablePOP > 0 ) mypw->pw_gid |= NO_POP;
if( DisableIMAP > 0 ) mypw->pw_gid |= NO_IMAP;
if( DisableDialup > 0 ) mypw->pw_gid |= NO_DIALUP;
if( DisablePasswordChanging > 0 ) mypw->pw_gid |= NO_PASSWD_CHNG;
if( DisableWebmail > 0 ) mypw->pw_gid |= NO_WEBMAIL;
if( DisableRelay > 0 ) mypw->pw_gid |= NO_RELAY;
if( DefaultQuota[0]!= 0 ) mypw->pw_shell = DefaultQuota;
/* update the user information */
if ( vauth_setpw( mypw, Domain ) != VA_SUCCESS ) {
/* report error */
sprintf(StatusMessage, "%s %s@%s (%s) %s",
get_html_text("002"), Newu, Domain, Gecos,
get_html_text("120"));
} else {
/* report success */
sprintf(StatusMessage, "%s %s@%s (%s) %s",
get_html_text("002"), Newu, Domain, Gecos,
get_html_text("119"));
}
/* otherwise, report error */
} else {
sprintf(StatusMessage, "<font color=\"red\">%s %s@%s (%s) %s</font>",
get_html_text("002"), Newu, Domain, Gecos, get_html_text("120"));
}
call_hooks( HOOK_ADDUSER );
/* After we add the user, show the user page
* people like to visually verify the results
*/
show_users(Username, Domain, Mytime);
}
int main(int argc, char **argv)
{
int xx, i;
#ifdef STOP_UAC
int nvpair[2];
#endif
char buf[520], s[25];
FILE *f;
#ifndef ENABLE_STRIP
struct rlimit cdlim;
#endif
/* Don't allow Eggdrop to run as root. */
if (((int) getuid() == 0) || ((int) geteuid() == 0))
fatal("ERROR: Eggdrop will not run as root!", 0);
#ifndef ENABLE_STRIP
cdlim.rlim_cur = RLIM_INFINITY;
cdlim.rlim_max = RLIM_INFINITY;
setrlimit(RLIMIT_CORE, &cdlim);
#endif
#include "patch.h"
/* Version info! */
egg_snprintf(ver, sizeof ver, "eggdrop v%s", egg_version);
egg_snprintf(version, sizeof version,
"Eggdrop v%s (C) 1997 Robey Pointer (C) 2005 Eggheads",
egg_version);
/* Now add on the patchlevel (for Tcl) */
sprintf(&egg_version[strlen(egg_version)], " %u", egg_numver);
strcat(egg_version, egg_xtra);
#ifdef STOP_UAC
nvpair[0] = SSIN_UACPROC;
nvpair[1] = UAC_NOPRINT;
setsysinfo(SSI_NVPAIRS, (char *) nvpair, 1, NULL, 0);
#endif
/* Set up error / signal traps. */
setup_signal_traps();
/* Initialize a few variables before main loop. */
cache_miss = 0;
cache_hit = 0;
chanset = NULL;
now = time(NULL);
egg_memcpy(&nowtm, localtime(&now), sizeof(struct tm));
lastmin = nowtm.tm_min;
/* Initialize random number generator. */
srandom((unsigned int) (now % (getpid() + getppid())));
init_mem();
init_language(1);
/* Process command line arguments. */
process_args(argc, argv);
printf("\n%s\n", version);
init_dcc_max();
init_userent();
logfile_init(0);
init_bots();
init_net();
init_modules();
if (backgrd)
bg_prepare_split();
init_tcl(argc, argv);
init_language(0);
help_init();
traffic_init();
logfile_init(1);
#ifdef STATIC
link_statics();
#endif
strncpyz(s, ctime(&now), sizeof s);
strcpy(&s[11], &s[20]);
putlog(LOG_ALL, "*", "--- Loading %s (%s)", ver, s);
/* Read configuration data. */
readconfig();
/* Check for encryption module. */
if (!encrypt_pass) {
printf(MOD_NOCRYPT);
bg_send_quit(BG_ABORT);
exit(1);
}
putlog(LOG_MISC, "*", "=== %s: %d channels, %d users.", botnetnick,
count_channels(), count_users(userlist));
if (!pid_file[0])
egg_snprintf(pid_file, sizeof pid_file, "pid.%s", botnetnick);
/* Check for pre-existing eggdrop! */
f = fopen(pid_file, "r");
if (f != NULL) {
fgets(s, 10, f);
xx = atoi(s);
kill(xx, SIGCHLD); /* Meaningless kill to determine if PID is used. */
if (errno != ESRCH) {
printf(EGG_RUNNING1, botnetnick);
printf(EGG_RUNNING2, pid_file);
bg_send_quit(BG_ABORT);
exit(1);
}
}
/* Move into background? */
if (backgrd) {
#ifndef CYGWIN_HACKS
bg_do_split();
}
else {
#endif
xx = getpid();
if (xx != 0) {
FILE *fp;
/* Write PID to file. */
unlink(pid_file);
fp = fopen(pid_file, "w");
if (fp != NULL) {
fprintf(fp, "%u\n", xx);
if (fflush(fp)) {
/* Let the bot live since this doesn't appear to be a botchk. */
printf("Cannot not write to '%s' (PID file).\n", pid_file);
fclose(fp);
unlink(pid_file);
}
else
fclose(fp);
}
else
printf("Cannot not write to '%s' (PID file).\n", pid_file);
#ifdef CYGWIN_HACKS
printf("Launched into the background (PID: %d)\n\n", xx);
#endif
}
}
use_stderr = 0; /* Stop writing to stderr now */
if (backgrd) {
/* Ok, try to disassociate from controlling terminal (finger cross) */
#if defined(HAVE_SETPGID) && !defined(CYGWIN_HACKS)
setpgid(0, 0);
#endif
/* Tcl wants the stdin, stdout and stderr file handles kept open. */
freopen("/dev/null", "r", stdin);
freopen("/dev/null", "w", stdout);
freopen("/dev/null", "w", stderr);
#ifdef CYGWIN_HACKS
FreeConsole();
#endif
}
/* Terminal emulating dcc chat */
if (!backgrd && term_z) {
int n = new_dcc(&DCC_CHAT, sizeof(struct chat_info));
dcc[n].addr = iptolong(getmyip());
dcc[n].sock = STDOUT;
dcc[n].timeval = now;
dcc[n].u.chat->con_flags = conmask;
dcc[n].u.chat->strip_flags = STRIP_ALL;
dcc[n].status = STAT_ECHO;
strcpy(dcc[n].nick, "HQ");
strcpy(dcc[n].host, "llama@console");
/* HACK: Workaround not to pass literal "HQ" as a non-const arg */
dcc[n].user = get_user_by_handle(userlist, dcc[n].nick);
/* Make sure there's an innocuous HQ user if needed */
if (!dcc[n].user) {
userlist = adduser(userlist, dcc[n].nick, "none", "-", USER_PARTY);
dcc[n].user = get_user_by_handle(userlist, dcc[n].nick);
}
setsock(STDOUT, 0); /* Entry in net table */
dprintf(n, "\n### ENTERING DCC CHAT SIMULATION ###\n\n");
dcc_chatter(n);
}
then = now;
online_since = now;
autolink_cycle(NULL); /* Hurry and connect to tandem bots. */
add_help_reference("cmds1.help");
add_help_reference("cmds2.help");
add_help_reference("core.help");
/* Create hooks. */
add_hook(HOOK_SECONDLY, (Function) core_secondly);
add_hook(HOOK_MINUTELY, (Function) core_minutely);
add_hook(HOOK_HOURLY, (Function) core_hourly);
add_hook(HOOK_REHASH, (Function) event_rehash);
add_hook(HOOK_PRE_REHASH, (Function) event_prerehash);
add_hook(HOOK_USERFILE, (Function) event_save);
add_hook(HOOK_BACKUP, (Function) backupuserfile);
add_hook(HOOK_DAILY, (Function) event_logfile);
add_hook(HOOK_DAILY, (Function) traffic_reset);
add_hook(HOOK_LOADED, (Function) event_loaded);
call_hook(HOOK_LOADED);
debug0("main: entering loop");
while (1) {
int socket_cleanup = 0;
#ifdef USE_TCL_EVENTS
/* Process a single Tcl event. */
Tcl_DoOneEvent(TCL_ALL_EVENTS | TCL_DONT_WAIT);
#endif
now = time(NULL);
random();
/* Every second... */
if (now != then) {
call_hook(HOOK_SECONDLY);
then = now;
}
/* Only do this every so often. */
if (!socket_cleanup) {
socket_cleanup = 5;
/* Remove dead dcc entries. */
dcc_remove_lost();
/* Check for server or dcc activity. */
dequeue_sockets();
}
else {
socket_cleanup--;
}
/* Free unused structures. */
garbage_collect();
xx = sockgets(buf, &i);
if (xx >= 0) { /* Non-error */
int idx;
for (idx = 0; idx < dcc_total; idx++) {
if (dcc[idx].sock != xx)
continue;
if (dcc[idx].type && dcc[idx].type->activity) {
traffic_update_in(dcc[idx].type, (strlen(buf) + 1)); /* Traffic stats. */
dcc[idx].type->activity(idx, buf, i);
}
else {
putlog(LOG_MISC, "*", "!!! untrapped dcc activity: type %s, sock %d",
dcc[idx].type->name, dcc[idx].sock);
}
break;
}
}
else if (xx == -1) { /* EOF */
int idx;
if (i == STDOUT && !backgrd)
fatal("END OF FILE ON TERMINAL", 0);
for (idx = 0; idx < dcc_total; idx++) {
if (dcc[idx].sock != i)
continue;
if (dcc[idx].type && dcc[idx].type->eof) {
dcc[idx].type->eof(idx);
}
else {
putlog(LOG_MISC, "*",
"*** ATTENTION: DEAD SOCKET (%d) OF TYPE %s UNTRAPPED",
i, dcc[idx].type ? dcc[idx].type->name : "*UNKNOWN*");
killsock(i);
lostdcc(idx);
}
idx = dcc_total + 1;
}
if (idx == dcc_total) {
putlog(LOG_MISC, "*",
"(@) EOF socket %d, not a dcc socket, not anything.", i);
close(i);
killsock(i);
}
}
else if (xx == -2 && errno != EINTR) { /* select() error */
putlog(LOG_MISC, "*", "* Socket error #%d; recovering.", errno);
for (i = 0; i < dcc_total; i++) {
if ((fcntl(dcc[i].sock, F_GETFD, 0) == -1) && (errno == EBADF)) {
putlog(LOG_MISC, "*",
"DCC socket %d (type %d, name '%s') expired -- pfft",
dcc[i].sock, dcc[i].type, dcc[i].nick);
killsock(dcc[i].sock);
lostdcc(i);
i--;
}
}
}
else if (xx == -3) {
call_hook(HOOK_IDLE);
socket_cleanup = 0; /* If we've been idle, cleanup & flush */
}
if (do_restart) {
if (do_restart == -2) {
rehash();
}
else {
int f = 1;
module_entry *p;
Function startfunc;
char name[256];
check_tcl_event("prerestart");
/* Unload as many modules as possible */
while (f) {
f = 0;
for (p = module_list; p != NULL; p = p->next) {
dependancy *d = dependancy_list;
int ok = 1;
while (ok && d) {
if (d->needed == p)
ok = 0;
d = d->next;
}
if (ok) {
strcpy(name, p->name);
if (module_unload(name, botnetnick) == NULL) {
f = 1;
break;
}
}
}
}
/* Make sure we don't have any modules left hanging around other than
* "eggdrop" and the two that are supposed to be.
*/
for (f = 0, p = module_list; p; p = p->next) {
if (strcmp(p->name, "eggdrop") && strcmp(p->name, "encryption") &&
strcmp(p->name, "uptime")) {
f++;
}
}
if (f != 0) {
putlog(LOG_MISC, "*", MOD_STAGNANT);
}
/* Flush log files to disk. */
flushlogs();
/* Clean up Tcl stuff. */
kill_tcl();
/* Initialize stuff again. */
init_tcl(argc, argv);
init_language(0);
help_init();
traffic_init();
logfile_init(1);
/* This resets our modules which we didn't unload (encryption and uptime). */
for (p = module_list; p; p = p->next) {
if (p->funcs) {
startfunc = p->funcs[MODCALL_START];
startfunc(NULL);
}
}
rehash();
restart_chons();
call_hook(HOOK_LOADED);
}
do_restart = 0;
}
}
}
void load_internal_users()
{
char *p = NULL, *ln = NULL, *hand = NULL, *ip = NULL, *port = NULL, *pass = NULL, *q = NULL;
char *hosts = NULL, buf[2048] = "", *attr = NULL, tmp[51] = "";
int i, hublevel = 0;
struct bot_addr *bi = NULL;
struct userrec *u = NULL;
/* hubs */
strlcpy(buf, settings.hubs, sizeof(buf));
p = buf;
while (p) {
ln = p;
p = strchr(p, ',');
if (p)
*p++ = 0;
hand = ln;
ip = NULL;
port = NULL;
u = NULL;
for (i = 0; ln; i++) {
switch (i) {
case 0:
hand = ln;
break;
case 1:
ip = ln;
break;
case 2:
port = ln;
hublevel++; /* We must increment this even if it is already added */
if (!get_user_by_handle(userlist, hand)) {
userlist = adduser(userlist, hand, "none", "-", USER_OP, 1);
u = get_user_by_handle(userlist, hand);
simple_snprintf(tmp, sizeof(tmp), "%li [internal]", (long)now);
set_user(&USERENTRY_ADDED, u, tmp);
bi = (struct bot_addr *) my_calloc(1, sizeof(struct bot_addr));
bi->address = strdup(ip);
bi->telnet_port = atoi(port) ? atoi(port) : 0;
bi->relay_port = bi->telnet_port;
bi->hublevel = hublevel;
if (conf.bot->hub && (!bi->hublevel) && (!strcasecmp(hand, conf.bot->nick)))
bi->hublevel = 99;
bi->uplink = (char *) my_calloc(1, 1);
set_user(&USERENTRY_BOTADDR, u, bi);
/* set_user(&USERENTRY_PASS, get_user_by_handle(userlist, hand), SALT2); */
}
break;
default:
break;
}
if (ln && (ln = strchr(ln, ' ')))
*ln++ = 0;
}
}
/* perm owners */
owner[0] = 0;
strlcpy(buf, settings.owners, sizeof(buf));
p = buf;
while (p) {
ln = p;
p = strchr(p, ',');
if (p)
*p++ = 0;
hand = ln;
pass = NULL;
attr = NULL;
hosts = NULL;
for (i = 0; ln; i++) {
switch (i) {
case 0:
hand = ln;
break;
case 1:
pass = ln;
if (ln && (ln = strchr(ln, ' ')))
*ln++ = 0;
hosts = ln;
if (owner[0])
strlcat(owner, ",", 121);
strlcat(owner, hand, 121);
if (!get_user_by_handle(userlist, hand)) {
userlist = adduser(userlist, hand, "none", "-", USER_ADMIN | USER_OWNER | USER_MASTER | USER_OP | USER_PARTY | USER_HUBA | USER_CHUBA, 0);
u = get_user_by_handle(userlist, hand);
set_user(&USERENTRY_PASS, u, pass);
simple_snprintf(tmp, sizeof(tmp), "%li [internal]", (long)now);
set_user(&USERENTRY_ADDED, u, tmp);
while (hosts) {
char x[1024] = "";
if ((ln = strchr(ln, ' ')))
*ln++ = 0;
if ((q = strchr(hosts, '!'))) { /* skip over nick they provided ... */
q++;
if (*q == '*' || *q == '?') /* ... and any '*' or '?' */
q++;
hosts = q;
}
simple_snprintf(x, sizeof(x), "-telnet!%s", hosts);
set_user(&USERENTRY_HOSTS, u, x);
hosts = ln;
}
}
break;
default:
break;
}
if (ln && (ln = strchr(ln, ' ')))
*ln++ = 0;
}
}
// Add HQ in if needed
if (!backgrd && term_z) {
strlcat(owner, ",HQ", sizeof(owner));
}
}
void gest_ihm(int signum, siginfo_t * info, void * vide) {
SigMsg *sigMsg = (SigMsg*) info->si_value.sival_ptr;
fprintf(stderr, "gest_ihm %d \n", sigMsg->val);
attenteTraitement |= sigMsg->val;
if ( PHASE_SESSION & sigMsg->val) {
printf("pl %s \n", sigMsg->data);
init_plateau(initPl);
parse_plateau(sigMsg->data, initPl);
cpyPlateau(initPl, pl);
display_plateau(pl);
}
if ( PHASE_REFLEX & sigMsg->val) {
printf("phase reflexion %s , %s\n", sigMsg->data, sigMsg->data2);
parse_enigme(sigMsg->data, &initEnigme);
parse_bilan(sigMsg->data2, &bilan);
cpyEnigme(&initEnigme, &enigme);
cpyPlateau(initPl, pl);
bind_enigme_plateau(pl, &enigme);
currentPhase = PHASE_REFLEX;
onclickReset(pl, &enigme, coups, moves);
display_bilan(&bilan);
displayMsg("REFLEXION", TRUE);
timeStart = SDL_GetTicks();
free(sigMsg->data);
free(sigMsg->data2);
}
if ( PHASE_ENCHERE & sigMsg->val) {
currentPhase = PHASE_ENCHERE;
displayMsg("ENCHERE", TRUE);
timeStart = SDL_GetTicks();
}
if ( PHASE_RESO & sigMsg->val) {
currentPhase = PHASE_RESO;
displayMsg("SOLUTION", TRUE);
timeStart = SDL_GetTicks();
}
if ( UPDATE_L & sigMsg->val) {
if (sigMsg->data != NULL && sigMsg->u == NULL) {
adduser(sigMsg->data, 0, &bilan.list_users);
free(sigMsg->data);
}
if (sigMsg->data2 != NULL && sigMsg->u == NULL) {
removeuser(sigMsg->data2, &bilan.list_users);
free(sigMsg->data2);
}
display_bilan(&bilan);
}
if ( UPDATE_U & sigMsg->val) {
if (sigMsg->data != NULL && sigMsg->data2 != NULL) {
user_t *u = getuser(sigMsg->data, &bilan.list_users);
if (u == NULL) {
printf(stderr, "erreur user not exist %s", sigMsg->data);
} else {
u->nb_coups = atoi(sigMsg->data2);
}
}
display_bilan(&bilan);
}
if ( SIGALEMENT & sigMsg->val) {
displayMsg(msg_signal, FALSE);
}
free(sigMsg);
}
/* Dependant on revenge_mode, punish the offender.
*/
static void punish_badguy(struct chanset_t *chan, char *whobad,
struct userrec *u, char *badnick, char *victim,
int mevictim, int type)
{
char reason[1024], ct[81], *kick_msg;
memberlist *m;
struct flag_record fr = { FR_GLOBAL | FR_CHAN, 0, 0, 0, 0, 0 };
m = ismember(chan, badnick);
if (!m)
return;
get_user_flagrec(u, &fr, chan->dname);
/* Get current time into a string */
egg_strftime(ct, 7, "%d %b", localtime(&now));
/* Put together log and kick messages */
reason[0] = 0;
switch (type) {
case REVENGE_KICK:
kick_msg = IRC_KICK_PROTECT;
simple_sprintf(reason, "kicked %s off %s", victim, chan->dname);
break;
case REVENGE_DEOP:
simple_sprintf(reason, "deopped %s on %s", victim, chan->dname);
kick_msg = IRC_DEOP_PROTECT;
break;
default:
kick_msg = "revenge!";
}
putlog(LOG_MISC, chan->dname, "Punishing %s (%s)", badnick, reason);
/* Set the offender +d */
if ((chan->revenge_mode > 0) && !(chan_deop(fr) || glob_deop(fr))) {
char s[UHOSTLEN], s1[UHOSTLEN];
memberlist *mx = NULL;
/* Removing op */
if (chan_op(fr) || (glob_op(fr) && !chan_deop(fr))) {
fr.match = FR_CHAN;
if (chan_op(fr))
fr.chan &= ~USER_OP;
else
fr.chan |= USER_DEOP;
set_user_flagrec(u, &fr, chan->dname);
putlog(LOG_MISC, "*", "No longer opping %s[%s] (%s)", u->handle, whobad,
reason);
}
/* ... or just setting to deop */
else if (u) {
/* In the user list already, cool :) */
fr.match = FR_CHAN;
fr.chan |= USER_DEOP;
set_user_flagrec(u, &fr, chan->dname);
simple_sprintf(s, "(%s) %s", ct, reason);
putlog(LOG_MISC, "*", "Now deopping %s[%s] (%s)", u->handle, whobad, s);
}
/* ... or creating new user and setting that to deop */
else {
strcpy(s1, whobad);
maskaddr(s1, s, chan->ban_type);
strcpy(s1, badnick);
/* If that handle exists use "badX" (where X is an increasing number)
* instead.
*/
while (get_user_by_handle(userlist, s1)) {
if (!strncmp(s1, "bad", 3)) {
int i;
i = atoi(s1 + 3);
simple_sprintf(s1 + 3, "%d", i + 1);
} else
strcpy(s1, "bad1"); /* Start with '1' */
}
userlist = adduser(userlist, s1, s, "-", 0);
fr.match = FR_CHAN;
fr.chan = USER_DEOP;
fr.udef_chan = 0;
u = get_user_by_handle(userlist, s1);
if ((mx = ismember(chan, badnick)))
mx->user = u;
set_user_flagrec(u, &fr, chan->dname);
simple_sprintf(s, "(%s) %s (%s)", ct, reason, whobad);
set_user(&USERENTRY_COMMENT, u, (void *) s);
putlog(LOG_MISC, "*", "Now deopping %s (%s)", whobad, reason);
}
}
/* Always try to deop the offender */
if (!mevictim)
add_mode(chan, '-', 'o', badnick);
/* Ban. Should be done before kicking. */
if (chan->revenge_mode > 2) {
char s[UHOSTLEN], s1[UHOSTLEN];
splitnick(&whobad);
maskaddr(whobad, s1, chan->ban_type);
simple_sprintf(s, "(%s) %s", ct, reason);
u_addban(chan, s1, botnetnick, s, now + (60 * chan->ban_time), 0);
if (!mevictim && HALFOP_CANDOMODE('b')) {
add_mode(chan, '+', 'b', s1);
flush_mode(chan, QUICK);
}
}
/* Kick the offender */
if (!mevictim && (chan->revenge_mode > 1) && (!channel_dontkickops(chan) ||
(!chan_op(fr) && (!glob_op(fr) || chan_deop(fr)))) &&
!chan_sentkick(m) && (me_op(chan) || (me_halfop(chan) &&
!chan_hasop(m) && (strchr(NOHALFOPS_MODES, 'b') == NULL)))) {
dprintf(DP_MODE, "KICK %s %s :%s\n", chan->name, badnick, kick_msg);
m->flags |= SENTKICK;
}
}
int process_cmd(json_item *ijson, struct _cmd_process *pc, subuser **iuser, acetables *g_ape)
{
callback *cmdback, tmpback = {handle_bad_cmd, NEED_NOTHING};
json_item *rjson = json_lookup(ijson->jchild.child, "cmd"), *jchl;
subuser *sub = pc->sub;
unsigned int flag;
unsigned short int attach = 1;
if (rjson != NULL && rjson->jval.vu.str.value != NULL) {
callbackp cp;
cp.client = NULL;
cp.cmd = rjson->jval.vu.str.value;
cp.data = NULL;
cp.hlines = NULL;
json_item *jsid;
if ((cmdback = (callback *)hashtbl_seek(g_ape->hCallback, rjson->jval.vu.str.value)) == NULL) {
cmdback = &tmpback;
}
if ((pc->guser == NULL && (jsid = json_lookup(ijson->jchild.child, "sessid")) != NULL && jsid->jval.vu.str.value != NULL)) {
pc->guser = seek_user_id(jsid->jval.vu.str.value, g_ape);
}
if (cmdback->need != NEED_NOTHING || pc->guser != NULL) { // We process the connection like a "NEED_SESSID" if the user provide its key
if (pc->guser == NULL) {
RAW *newraw;
json_item *jlist = json_new_object();
json_set_property_strZ(jlist, "code", "004");
json_set_property_strZ(jlist, "value", "BAD_SESSID");
newraw = forge_raw(RAW_ERR, jlist);
send_raw_inline(pc->client, pc->transport, newraw, g_ape);
return (CONNECT_SHUTDOWN);
} else if (sub == NULL) {
sub = getsubuser(pc->guser, pc->host);
if (sub != NULL && sub->client->fd != pc->client->fd && sub->state == ALIVE) {
/* The user open a new connection while he already has one openned */
struct _transport_open_same_host_p retval = transport_open_same_host(sub, pc->client, pc->guser->transport);
if (retval.client_close != NULL) {
// Send CLOSE if no response has been sent yet
if (!sub->headers.sent) {
RAW *newraw;
json_item *jlist = json_new_object();
json_set_property_strZ(jlist, "value", "null");
newraw = forge_raw("CLOSE", jlist);
send_raw_inline((retval.client_close->fd == pc->client->fd ? pc->client : sub->client), pc->transport, newraw, g_ape);
}
// It's not safe to leave the subuser pointer in co->attach anymore
// since subuser could subsequently be deleted, leaving a pointer into free heap.
// So, let this socket finish up on its own and pretend its already finished.
sub->state = ADIED;
sub->headers.sent = 0;
http_headers_free(sub->headers.content);
sub->headers.content = NULL;
sub->burn_after_writing = 0;
g_ape->co[retval.client_close->fd]->attach = NULL;
safe_shutdown(retval.client_close->fd, g_ape);
}
sub->client = cp.client = retval.client_listener;
sub->state = retval.substate;
attach = retval.attach;
} else if (sub == NULL) {
sub = addsubuser(pc->client, pc->host, pc->guser, g_ape);
if (sub != NULL) {
subuser_restor(sub, g_ape);
}
} else if (sub != NULL) {
sub->client = pc->client;
}
pc->guser->idle = (long int)time(NULL); // update user idle
sub->idle = pc->guser->idle; // Update subuser idle
}
}
if (pc->guser != NULL && sub != NULL && (jchl = json_lookup(ijson->jchild.child, "chl")) != NULL /*&& jchl->jval.vu.integer_value > sub->current_chl*/) {
sub->current_chl = jchl->jval.vu.integer_value;
}
#if 0
else if (pc->guser != NULL && sub != NULL) {
/* if a bad challenge is detected, we are stoping walking on cmds */
send_error(pc->guser, "BAD_CHL", "250", g_ape);
sub->state = ALIVE;
return (CONNECT_KEEPALIVE);
}
#endif
cp.param = json_lookup(ijson->jchild.child, "params");
cp.client = (cp.client != NULL ? cp.client : pc->client);
cp.call_user = pc->guser;
cp.call_subuser = sub;
cp.g_ape = g_ape;
cp.host = pc->host;
cp.ip = pc->ip;
cp.chl = (sub != NULL ? sub->current_chl : 0);
cp.transport = pc->transport;
cp.hlines = pc->hlines;
/* Little hack to access user object on connect hook callback (preallocate an user) */
if (strncasecmp(cp.cmd, "CONNECT", 7) == 0 && cp.cmd[7] == '\0') {
pc->guser = cp.call_user = adduser(cp.client, cp.host, cp.ip, NULL, g_ape);
pc->guser->transport = pc->transport;
sub = cp.call_subuser = cp.call_user->subuser;
}
if ((flag = call_cmd_hook(cp.cmd, &cp, g_ape)) == RETURN_CONTINUE) {
flag = cmdback->func(&cp);
}
if (flag & RETURN_NULL) {
pc->guser = NULL;
} else if (flag & RETURN_BAD_PARAMS) {
RAW *newraw;
json_item *jlist = json_new_object();
if (cp.chl) {
json_set_property_intN(jlist, "chl", 3, cp.chl);
}
json_set_property_strZ(jlist, "code", "001");
json_set_property_strZ(jlist, "value", "BAD_PARAMS");
newraw = forge_raw(RAW_ERR, jlist);
if (cp.call_user != NULL) {
//cp.call_user->istmp = 0;
if (sub == NULL) {
sub = getsubuser(pc->guser, pc->host);
}
post_raw_sub(newraw, sub, g_ape);
} else {
send_raw_inline(pc->client, pc->transport, newraw, g_ape);
}
//guser = NULL;
} else if (flag & RETURN_BAD_CMD) {
RAW *newraw;
json_item *jlist = json_new_object();
if (cp.chl) {
json_set_property_intN(jlist, "chl", 3, cp.chl);
}
json_set_property_strZ(jlist, "code", "003");
json_set_property_strZ(jlist, "value", "BAD_CMD");
newraw = forge_raw(RAW_ERR, jlist);
if (cp.call_user != NULL) {
if (sub == NULL) {
sub = getsubuser(pc->guser, pc->host);
}
post_raw_sub(newraw, sub, g_ape);
} else {
send_raw_inline(pc->client, pc->transport, newraw, g_ape);
}
}
if (pc->guser != NULL) {
if (sub == NULL) {
sub = getsubuser(pc->guser, pc->host);
}
if (iuser != NULL) {
*iuser = (attach ? sub : NULL);
}
/* If tmpfd is set, we do not have any reasons to change its state */
sub->state = ALIVE;
if (flag & RETURN_HANG || flag & RETURN_BAD_PARAMS) {
return (CONNECT_KEEPALIVE);
}
} else if (flag & RETURN_HANG) {
/* Doesn't need sessid */
return (CONNECT_KEEPALIVE);
} else {
return (CONNECT_SHUTDOWN);
}
} else {
RAW *newraw;
json_item *jlist = json_new_object();
json_set_property_strZ(jlist, "code", "003");
json_set_property_strZ(jlist, "value", "NO_CMD");
newraw = forge_raw(RAW_ERR, jlist);
send_raw_inline(pc->client, pc->transport, newraw, g_ape);
//printf("Cant find %s\n", rjson->jval.vu.str.value);
return (CONNECT_SHUTDOWN);
}
return -1;
}
