/* Get friend list of account */
extern int __account_get_friends(lua_State* L)
{
const char *username;
std::vector<std::map<std::string, std::string> > friends;
try
{
lua::stack st(L);
// get args
st.at(1, username);
if (t_account * account = accountlist_find_account(username))
if (t_list *friendlist = account_get_friends(account))
{
t_elem const * curr;
t_friend * f;
LIST_TRAVERSE_CONST(friendlist, curr)
{
if (!(f = (t_friend*)elem_get_data(curr)))
{
eventlog(eventlog_level_error, __FUNCTION__, "found NULL entry in list");
continue;
}
friends.push_back(get_friend_object(f));
}
}
st.push(friends);
}
extern int account_check_ignoring(t_account * account, char const * who)
{
char const * tignstr;
char * ignstr;
char * pignstr;
char * ttok;
t_account * tacc;
char const * account_name;
t_connection * c;
if (!account)
{
eventlog(eventlog_level_error,"account_check_ignoring","got NULL account");
return -1;
}
if (!(account_name = account_get_name(account)))
{
eventlog(eventlog_level_error,"account_check_ignoring","got NULL account_name");
return -1;
}
if ((c = connlist_find_connection_by_accountname(account_name)))
{
account_unget_name(account_name);
return conn_check_ignoring(c,who);
}
if (!(tignstr = account_get_ignore(account)))
{
eventlog(eventlog_level_error,"account_chceck_ignoring","got NULL tignstr");
account_unget_name(account_name);
return -1;
}
if (!(ignstr = strdup(tignstr)))
{
eventlog(eventlog_level_error,"conn_check_ignoring","cannot allocate memory for ignstr");
account_unget_ignore(ignstr);
account_unget_name(account_name);
return -1;
}
account_unget_ignore(tignstr);
pignstr = ignstr;
while ((ttok = strsep(&ignstr,",")))
if ((tacc = accountlist_find_account(ttok)))
if (strcasecmp(account_name,ttok)==0)
{
account_unget_name(account_name);
free(pignstr);
return 1;
}
account_unget_name(account_name);
free(pignstr);
return 0;
}
static void mail_func_send(t_connection * c, const char * str) {
int i;
char *dest;
char const *p,*myname;
t_account * recv;
t_mailbox * mailbox;
if (c==NULL) {
eventlog(eventlog_level_error,__FUNCTION__,"got NULL connection");
return;
}
if (str==NULL) {
eventlog(eventlog_level_error,__FUNCTION__,"got NULL command string");
return;
}
for(i=0;str[i]==' ';i++); /* skip any spaces */
if (str[i]=='\0') { /* the %mail send command has no receiver */
message_send_text(c,message_type_error,c,"You must specify the receiver");
message_send_text(c,message_type_error,c,"Syntax: /mail send <receiver> <message>");
return;
}
p=str+i; /* set ip at the start of receiver string */
for(i=1;p[i]!=' ' && p[i]!='\0';i++); /* skip the receiver string */
if (p[i]=='\0') { /* it seems user forgot to write any message */
message_send_text(c,message_type_error,c,"Your message is empty!");
message_send_text(c,message_type_error,c,"Syntax: /mail send <receiver> <message>");
return;
}
dest=xmalloc(i+1);
memmove(dest,p,i); dest[i]='\0'; /* copy receiver in his separate string */
if ((recv=accountlist_find_account(dest))==NULL) { /* is dest a valid account on this server ? */
message_send_text(c,message_type_error,c,"Receiver UNKNOWN!");
xfree(dest);
return;
}
xfree(dest); /* free dest here, the sooner the better */
if ((mailbox=mailbox_open(recv, mbox_mode_write))==NULL) {
message_send_text(c,message_type_error,c,"There was an error completing your request!");
return;
}
if (get_mail_quota(recv)<=mailbox_count(mailbox)) { /* check quota */
message_send_text(c,message_type_error,c,"Receiver has reached his mail quota. Your message will NOT be sent.");
mailbox_close(mailbox);
return;
}
myname=conn_get_username(c); /* who am i ? */
if (mailbox_deliver(mailbox,myname,p+i+1)<0)
message_send_text(c,message_type_error,c,"There was an error completing your request!");
else
message_send_text(c,message_type_info,c,"Your mail has been sent successfully.");
mailbox_close(mailbox);
}
/* Get account attribute value */
extern int __account_get_attr(lua_State* L)
{
const char *username, *attrkey;
int attrtype;
std::string attrvalue;
std::map<std::string, std::string> o_account;
try
{
lua::stack st(L);
// get args
st.at(1, username);
st.at(2, attrkey);
st.at(3, attrtype);
if (t_account *account = accountlist_find_account(username))
{
switch ((t_attr_type)attrtype)
{
case attr_type_str:
attrvalue = account_get_strattr(account, attrkey);
break;
case attr_type_num:
attrvalue = std_to_string(account_get_numattr(account, attrkey));
break;
case attr_type_bool:
attrvalue = account_get_boolattr(account, attrkey) == 0 ? "false" : "true";
break;
case attr_type_raw:
attrvalue = account_get_rawattr(account, attrkey);
break;
}
}
st.push(attrvalue);
}
catch (const std::exception& e)
{
eventlog(eventlog_level_error, __FUNCTION__, e.what());
}
catch (...)
{
eventlog(eventlog_level_error, __FUNCTION__, "lua exception\n");
}
return 1;
}
/* Get account attribute value */
extern int __account_get_attr(lua_State* L)
{
const char *username, *attrkey;
int attrtype;
try
{
lua::stack st(L);
// get args
st.at(1, username);
st.at(2, attrkey);
st.at(3, attrtype);
if (t_account *account = accountlist_find_account(username))
{
switch ((t_attr_type)attrtype)
{
case attr_type_str:
if (const char * val = account_get_strattr(account, attrkey))
st.push(val);
break;
case attr_type_num:
st.push(account_get_numattr(account, attrkey));
break;
case attr_type_bool:
st.push(account_get_boolattr(account, attrkey));
break;
case attr_type_raw:
if (const char * val = account_get_rawattr(account, attrkey))
st.push(val);
break;
}
}
}
catch (const std::exception& e)
{
eventlog(eventlog_level_error, __FUNCTION__, e.what());
}
catch (...)
{
eventlog(eventlog_level_error, __FUNCTION__, "lua exception\n");
}
return 1;
}
static void mail_func_send(t_connection * c, std::istream& istr)
{
if (!c) {
ERROR0("got NULL connection");
return;
}
std::string dest;
istr >> dest;
if (dest.empty()) {
message_send_text(c, message_type_error, c, "You must specify the receiver");
message_send_text(c, message_type_error, c, "Syntax: /mail send <receiver> <message>");
return;
}
std::string message;
std::getline(istr, message);
std::string::size_type pos(message.find_first_not_of(" \t"));
if (pos == std::string::npos) {
message_send_text(c, message_type_error, c, "Your message is empty!");
message_send_text(c, message_type_error, c, "Syntax: /mail send <receiver> <message>");
return;
}
t_account * recv = accountlist_find_account(dest.c_str());
if (!recv) {
message_send_text(c, message_type_error, c, "Receiver UNKNOWN!");
return;
}
Mailbox mbox(account_get_uid(recv));
if (get_mail_quota(recv) <= mbox.size()) {
message_send_text(c, message_type_error, c, "Receiver has reached his mail quota. Your message will NOT be sent.");
return;
}
try {
mbox.deliver(conn_get_username(c), message.substr(pos));
message_send_text(c, message_type_info, c, "Your mail has been sent successfully.");
}
catch (const Mailbox::DeliverError&) {
message_send_text(c, message_type_error, c, "There was an error completing your request!");
}
}
extern int bits_va_lock_account(const char *name) {
t_account * ac;
t_packet * p;
t_query * q;
if (!name) {
eventlog(eventlog_level_error,"bits_va_lock_account","got NULL name");
return -1;
}
if ((ac = accountlist_find_account(name))) {
if (account_get_bits_state(ac)!=account_state_unknown) {
eventlog(eventlog_level_warn,"bits_va_lock_account","tried to lock an account which is already locked");
return 0;
}
} else {
/* create a dummy account */
ac = create_vaccount(name,0);
if (!ac) {
eventlog(eventlog_level_error,"bits_va_lock_account","could not create dummy vaccount");
return -1;
}
}
p = packet_create(packet_class_bits);
packet_set_size(p, sizeof(t_bits_va_lock));
packet_set_type(p, BITS_VA_LOCK);
bits_packet_generic(p, BITS_ADDR_PEER);
q = query_create(bits_query_type_bits_va_lock);
if (!q) {
eventlog(eventlog_level_error,"bits_va_lock_account","bits_query_push failed.");
packet_destroy(p);
return -1;
}
/*bits_query_set_processed(q,-1);*/
bn_int_set(&p->u.bits_va_lock.qid,q->qid);
packet_append_string(p,name);
query_attach_account(q,"account",ac);
send_bits_packet_up(p);
packet_del_ref(p);
account_set_bits_state(ac,account_state_pending); /* request sent */
accountlist_add_account(ac);
return 0;
}
static t_account * account_create3(char const * username, char const * passhash1, char const * email)
{
t_account * account;
if (username && !passhash1) {
eventlog(eventlog_level_error,__FUNCTION__,"got NULL passhash1");
return NULL;
}
if (username && account_check_name(username)) {
eventlog(eventlog_level_error,__FUNCTION__,"got invalid chars in username");
return NULL;
}
account = xmalloc(sizeof(t_account));
account->name = NULL;
account->clanmember = NULL;
account->attrgroup = NULL;
account->friends = NULL;
account->teams = NULL;
account->conn = NULL;
FLAG_ZERO(&account->flags);
account->namehash = 0; /* hash it later before inserting */
account->uid = 0; /* hash it later before inserting */
if (username) { /* actually making a new account */
/* first check if such a username already owns an account.
* we search in the memory hash mainly for non-indexed storage types.
* indexed storage types check themselves if the username exists already
* in the storage (see storage_sql.c) */
if (accountlist_find_account(username)) {
eventlog(eventlog_level_debug,__FUNCTION__,"user \"%s\" already has an account",username);
goto err;
}
account->attrgroup = attrgroup_create_newuser(username);
if(!account->attrgroup) {
eventlog(eventlog_level_error,__FUNCTION__,"failed to add user");
goto err;
}
account->name = xstrdup(username);
if (account_set_strattr(account,"BNET\\acct\\username",username)<0) {
eventlog(eventlog_level_error,__FUNCTION__,"could not set username");
goto err;
}
if (account_set_numattr(account,"BNET\\acct\\userid",maxuserid+1)<0) {
eventlog(eventlog_level_error,__FUNCTION__,"could not set userid");
goto err;
}
if (account_set_strattr(account,"BNET\\acct\\passhash1",passhash1)<0) {
eventlog(eventlog_level_error,__FUNCTION__,"could not set passhash1");
goto err;
}
if (account_set_numattr(account,"BNET\\acct\\ctime",(unsigned int)now)) {
eventlog(eventlog_level_error,__FUNCTION__,"could not set ctime");
goto err;
}
if (account_set_strattr(account,"BNET\\acct\\email",email)<0) {
eventlog(eventlog_level_error,__FUNCTION__,"could not set email");
goto err;
}
if (account_set_numattr(account,"BNET\\auth\\vip_expire",(unsigned int)now+prefs_get_vip_experience())) {
eventlog(eventlog_level_error,__FUNCTION__,"could not set vip_expire");
goto err;
}
}
return account;
err:
account_destroy(account);
return NULL;
}
// handle command
// /log read user startline
// /log find user substr startline
extern int handle_log_command(t_connection * c, char const *text)
{
const char *subcommand, *username;
long startline = 0;
std::map<long, char*> lines;
// split command args
std::vector<std::string> args = split_command(text, 4);
if (args[1].empty() || args[2].empty()
|| (args[1].at(0) != 'r' && args[1].at(0) != 'f')) // check start symbols for subcommand
{
describe_command(c, args[0].c_str());
return -1;
}
subcommand = args[1].c_str(); // sub command
username = args[2].c_str(); // username
if (!accountlist_find_account(username))
{
message_send_text(c, message_type_error, c, localize(c, "Invalid user."));
return -1;
}
std::string title = localize(c, "{}'s log output", username);
// read
if (subcommand[0] == 'r')
{
if (!args[3].empty())
startline = atoi(args[3].c_str());
lines = userlog_read(username, startline);
}
// find
else if (subcommand[0] == 'f')
{
if (args[3].empty())
{
describe_command(c, args[0].c_str());
return -1;
}
const char * search = args[3].c_str();
title += localize(c, " by occurrence \"{}\"", search);
if (!args[4].empty())
startline = atoi(args[4].c_str());
lines = userlog_find_text(username, search, startline);
}
title += ":";
message_send_text(c, message_type_info, c, title);
int linelen = 0;
int paddedlen = 0;
std::string linenum;
// send each log line to user
for (std::map<long, char*>::reverse_iterator it = lines.rbegin(); it != lines.rend(); ++it)
{
int linelen = floor(log10(static_cast<double>(abs(it->first)))) + 1; // get length of integer (line number)
if (linelen > paddedlen)
paddedlen = linelen;
linenum = std_to_string(it->first);
// pad left to max line length
linenum.insert(linenum.begin(), paddedlen - linenum.size(), '0');
message_send_text(c, message_type_info, c, linenum + ": " + std::string(it->second));
}
return 0;
}
/* Set account attribute value
* (Return 0 if attribute is not set, and 1 if set)
*/
extern int __account_set_attr(lua_State* L)
{
const char *username, *attrkey;
int attrtype;
std::map<std::string, std::string> o_account;
int result = 0;
try
{
lua::stack st(L);
// get args
st.at(1, username);
st.at(2, attrkey);
st.at(3, attrtype);
if (t_account *account = accountlist_find_account(username))
{
switch ((t_attr_type)attrtype)
{
case attr_type_str:
const char * strvalue;
st.at(4, strvalue);
if (account_set_strattr(account, attrkey, strvalue) >= 0)
result = 1;
break;
case attr_type_num:
int numvalue;
st.at(4, numvalue);
if (account_set_numattr(account, attrkey, numvalue) >= 0)
result = 1;
break;
case attr_type_bool:
bool boolvalue;
st.at(4, boolvalue);
if (account_set_boolattr(account, attrkey, boolvalue ? 1 : 0) >= 0)
result = 1;
break;
case attr_type_raw:
const char * rawvalue;
int length;
st.at(4, rawvalue);
st.at(5, length);
if (account_set_rawattr(account, attrkey, rawvalue, length) >= 0)
result = 1;
break;
}
}
st.push(result);
}
catch (const std::exception& e)
{
eventlog(eventlog_level_error, __FUNCTION__, e.what());
}
catch (...)
{
eventlog(eventlog_level_error, __FUNCTION__, "lua exception\n");
}
return 1;
}
extern int handle_bot_packet(t_connection * c, t_packet const * const packet)
{
t_packet * rpacket;
if (!c)
{
eventlog(eventlog_level_error,__FUNCTION__,"[%d] got NULL connection",conn_get_socket(c));
return -1;
}
if (!packet)
{
eventlog(eventlog_level_error,__FUNCTION__,"[%d] got NULL packet",conn_get_socket(c));
return -1;
}
if (packet_get_class(packet)!=packet_class_raw)
{
eventlog(eventlog_level_error,__FUNCTION__,"[%d] got bad packet (class %d)",conn_get_socket(c),(int)packet_get_class(packet));
return -1;
}
{
char const * const linestr=packet_get_str_const(packet,0,MAX_MESSAGE_LEN);
if (packet_get_size(packet)<2) /* empty line */
return 0;
if (!linestr)
{
eventlog(eventlog_level_warn,__FUNCTION__,"[%d] line too long",conn_get_socket(c));
return 0;
}
switch (conn_get_state(c))
{
case conn_state_connected:
conn_add_flags(c,MF_PLUG);
conn_set_clienttag(c,CLIENTTAG_BNCHATBOT_UINT);
{
char const * temp=linestr;
if (temp[0]=='\004') /* FIXME: no echo, ignore for now (we always do no echo) */
temp = &temp[1];
if (temp[0]=='\0') /* empty line */
{
conn_set_state(c,conn_state_bot_username); /* don't look for ^D or reset tag and flags */
break;
}
conn_set_state(c,conn_state_bot_password);
if (conn_set_loggeduser(c,temp)<0)
eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not set username to \"%s\"",conn_get_socket(c),temp);
{
char const * const msg="\r\nPassword: "******"[%d] could not create rpacket",conn_get_socket(c));
break;
}
#if 1 /* don't echo */
packet_append_ntstring(rpacket,conn_get_loggeduser(c));
#endif
packet_append_ntstring(rpacket,msg);
conn_push_outqueue(c,rpacket);
packet_del_ref(rpacket);
}
}
break;
case conn_state_bot_username:
conn_set_state(c,conn_state_bot_password);
if (conn_set_loggeduser(c,linestr)<0)
eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not set username to \"%s\"",conn_get_socket(c),linestr);
{
char const * const temp="\r\nPassword: "******"[%d] could not create rpacket",conn_get_socket(c));
break;
}
#if 1 /* don't echo */
packet_append_ntstring(rpacket,linestr);
#endif
packet_append_ntstring(rpacket,temp);
conn_push_outqueue(c,rpacket);
packet_del_ref(rpacket);
}
break;
case conn_state_bot_password:
{
char const * const tempa="\r\nLogin failed.\r\n\r\nUsername: "******"\r\nAccount has no bot access.\r\n\r\nUsername: "******"[%d] could not create rpacket",conn_get_socket(c));
break;
}
packet_append_ntstring(rpacket,tempa);
conn_push_outqueue(c,rpacket);
packet_del_ref(rpacket);
break;
}
if (connlist_find_connection_by_accountname(loggeduser))
{
eventlog(eventlog_level_info,__FUNCTION__,"[%d] bot login for \"%s\" refused (already logged in)",conn_get_socket(c),loggeduser);
conn_set_state(c,conn_state_bot_username);
if (!(rpacket = packet_create(packet_class_raw)))
{
eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not create rpacket",conn_get_socket(c));
break;
}
packet_append_ntstring(rpacket,tempa);
conn_push_outqueue(c,rpacket);
packet_del_ref(rpacket);
break;
}
if (!(account = accountlist_find_account(loggeduser)))
{
eventlog(eventlog_level_info,__FUNCTION__,"[%d] bot login for \"%s\" refused (bad account)",conn_get_socket(c),loggeduser);
conn_set_state(c,conn_state_bot_username);
if (!(rpacket = packet_create(packet_class_raw)))
{
eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not create rpacket",conn_get_socket(c));
break;
}
packet_append_ntstring(rpacket,tempa);
conn_push_outqueue(c,rpacket);
packet_del_ref(rpacket);
break;
}
if ((oldstrhash1 = account_get_pass(account)))
{
if (hash_set_str(&oldpasshash1,oldstrhash1)<0)
{
eventlog(eventlog_level_info,__FUNCTION__,"[%d] bot login for \"%s\" refused (corrupted passhash1?)",conn_get_socket(c),loggeduser);
conn_set_state(c,conn_state_bot_username);
if (!(rpacket = packet_create(packet_class_raw)))
{
eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not create rpacket",conn_get_socket(c));
break;
}
packet_append_ntstring(rpacket,tempa);
conn_push_outqueue(c,rpacket);
packet_del_ref(rpacket);
break;
}
testpass = xstrdup(linestr);
{
unsigned int i;
for (i=0; i<strlen(testpass); i++)
if (isupper((int)testpass[i]))
testpass[i] = tolower((int)testpass[i]);
}
if (bnet_hash(&trypasshash1,strlen(testpass),testpass)<0) /* FIXME: force to lowercase */
{
eventlog(eventlog_level_info,__FUNCTION__,"[%d] bot login for \"%s\" refused (unable to hash password)",conn_get_socket(c), loggeduser);
conn_set_state(c,conn_state_bot_username);
xfree((void *)testpass);
if (!(rpacket = packet_create(packet_class_raw)))
{
eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not create rpacket",conn_get_socket(c));
break;
}
packet_append_ntstring(rpacket,tempa);
conn_push_outqueue(c,rpacket);
packet_del_ref(rpacket);
break;
}
xfree((void *)testpass);
if (hash_eq(trypasshash1,oldpasshash1)!=1)
{
eventlog(eventlog_level_info,__FUNCTION__,"[%d] bot login for \"%s\" refused (wrong password)",conn_get_socket(c), loggeduser);
conn_set_state(c,conn_state_bot_username);
if (!(rpacket = packet_create(packet_class_raw)))
{
eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not create rpacket",conn_get_socket(c));
break;
}
packet_append_ntstring(rpacket,tempa);
conn_push_outqueue(c,rpacket);
packet_del_ref(rpacket);
break;
}
if (account_get_auth_botlogin(account)!=1) /* default to false */
{
eventlog(eventlog_level_info,__FUNCTION__,"[%d] bot login for \"%s\" refused (no bot access)",conn_get_socket(c), loggeduser);
conn_set_state(c,conn_state_bot_username);
if (!(rpacket = packet_create(packet_class_raw)))
{
eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not create rpacket",conn_get_socket(c));
break;
}
packet_append_ntstring(rpacket,tempb);
conn_push_outqueue(c,rpacket);
packet_del_ref(rpacket);
break;
}
else if (account_get_auth_lock(account)==1) /* default to false */
{
eventlog(eventlog_level_info,__FUNCTION__,"[%d] bot login for \"%s\" refused (this account is locked)",conn_get_socket(c), loggeduser);
conn_set_state(c,conn_state_bot_username);
if (!(rpacket = packet_create(packet_class_raw)))
{
eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not create rpacket",conn_get_socket(c));
break;
}
packet_append_ntstring(rpacket,tempb);
conn_push_outqueue(c,rpacket);
packet_del_ref(rpacket);
break;
}
eventlog(eventlog_level_info,__FUNCTION__,"[%d] \"%s\" bot logged in (correct password)",conn_get_socket(c), loggeduser);
}
else
{
eventlog(eventlog_level_info,__FUNCTION__,"[%d] \"%s\" bot logged in (no password)",conn_get_socket(c), loggeduser);
}
if (!(rpacket = packet_create(packet_class_raw))) /* if we got this far, let them log in even if this fails */
eventlog(eventlog_level_error,__FUNCTION__,"[%d] could not create rpacket",conn_get_socket(c));
else
{
packet_append_ntstring(rpacket,"\r\n");
conn_push_outqueue(c,rpacket);
packet_del_ref(rpacket);
}
bnetd_log(loggeduser, addr_num_to_ip_str(conn_get_addr(c)), "BOT", "LOGIN", NULL, 1, 0);
conn_login(c,account,loggeduser);
message_send_text(c,message_type_uniqueid,c,loggeduser);
if (conn_set_channel(c,CHANNEL_NAME_CHAT)<0)
conn_set_channel(c,CHANNEL_NAME_BANNED); /* should not fail */
}
break;
case conn_state_loggedin:
{
t_channel const * channel;
conn_set_idletime(c);
if ((channel = conn_get_channel(c)))
channel_message_log(channel,c,1,linestr);
/* we don't log game commands currently */
if (linestr[0]=='/')
handle_command(c,linestr);
else
if (channel && !conn_quota_exceeded(c,linestr))
channel_message_send(channel,message_type_talk,c,linestr);
/* else discard */
}
break;
default:
eventlog(eventlog_level_error,__FUNCTION__,"[%d] unknown bot connection state %d",conn_get_socket(c),(int)conn_get_state(c));
}
}
return 0;
}
BOOL CALLBACK KickDlgProc(HWND hwnd, UINT Message, WPARAM wParam, LPARAM lParam)
{
switch (Message) {
case WM_INITDIALOG:
if (selected_item[0] != 0) {
SetDlgItemText(hwnd, IDC_EDITKICK, selected_item);
}
return TRUE;
case WM_COMMAND:
switch (LOWORD(wParam)) {
case IDC_KICK_EXECUTE:
{
t_connection * conngui;
t_account * accountgui;
BOOL messageq;
BOOL kickq;
char temp[60];
char ipadr[110];
messageq = FALSE;
kickq = FALSE;
GetDlgItemText(hwnd, IDC_EDITKICK, selected_item, 32);
conngui = connlist_find_connection_by_accountname(selected_item);
accountgui = accountlist_find_account(selected_item);
if (conngui == NULL) {
strcat(selected_item, " could not be found in Userlist!");
MessageBox(hwnd, selected_item, "ERROR", MB_OK);
}
else {
HWND hButton = GetDlgItem(hwnd, IDC_CHECKBAN);
HWND hButton1 = GetDlgItem(hwnd, IDC_CHECKKICK);
HWND hButton2 = GetDlgItem(hwnd, IDC_CHECKADMIN);
HWND hButton3 = GetDlgItem(hwnd, IDC_CHECKMOD);
HWND hButton4 = GetDlgItem(hwnd, IDC_CHECKANN);
if (SendMessage(hButton2, BM_GETCHECK, 0, 0) == BST_CHECKED) {
account_set_admin(accountgui);
account_set_command_groups(accountgui, 255);
messageq = TRUE;
}
if (SendMessage(hButton3, BM_GETCHECK, 0, 0) == BST_CHECKED) {
account_set_auth_operator(accountgui, NULL, 1);
messageq = TRUE;
}
if (SendMessage(hButton4, BM_GETCHECK, 0, 0) == BST_CHECKED) {
account_set_strattr(accountgui, "BNET\\auth\\announce", "true");
messageq = TRUE;
}
if (SendMessage(hButton, BM_GETCHECK, 0, 0) == BST_CHECKED) {
unsigned int i_GUI;
strcpy(temp, addr_num_to_addr_str(conn_get_addr(conngui), 0));
for (i_GUI = 0; temp[i_GUI] != ':'; i_GUI++)
ipadr[i_GUI] = temp[i_GUI];
ipadr[i_GUI] = 0;
strcpy(temp, " a ");
strcat(temp, ipadr);
handle_ipban_command(NULL, temp);
temp[0] = 0;
strcpy(temp, " has been added to IpBanList");
strcat(ipadr, temp);
if (messageq == TRUE) {
strcat(ipadr, " and UserStatus changed");
MessageBox(hwnd, ipadr, "ipBan & StatusChange", MB_OK);
messageq = FALSE;
kickq = FALSE;
}
else
MessageBox(hwnd, ipadr, "ipBan", MB_OK);
}
if (SendMessage(hButton1, BM_GETCHECK, 0, 0) == BST_CHECKED) {
conn_set_state(conngui, conn_state_destroy);
kickq = TRUE;
}
if ((messageq == TRUE) && (kickq == TRUE)) {
strcat(selected_item, "has been kicked and Status has changed");
MessageBox(hwnd, selected_item, "UserKick & StatusChange", MB_OK);
}
if ((kickq == TRUE) && (messageq == FALSE)) {
strcat(selected_item, " has been kicked from the server");
MessageBox(hwnd, selected_item, "UserKick", MB_OK);
}
if ((kickq == FALSE) && (messageq == TRUE)) {
strcat(selected_item, "'s Status has been changed");
MessageBox(hwnd, selected_item, "StatusChange", MB_OK);
}
selected_item[0] = 0;
}
break;
}
}
break;
case WM_CLOSE:
EndDialog(hwnd, IDC_EDITKICK);
break;
default:
return FALSE;
}
return TRUE;
}
extern int irc_authenticate(t_connection * conn, char const * passhash)
{
t_hash h1;
t_hash h2;
t_account * a;
char const * temphash;
char const * username;
char const * tempapgar;
if (!conn) {
eventlog(eventlog_level_error,__FUNCTION__,"got NULL connection");
return 0;
}
if (!passhash) {
eventlog(eventlog_level_error,__FUNCTION__,"got NULL passhash");
return 0;
}
username = conn_get_loggeduser(conn);
if (!username) {
/* redundant sanity check */
eventlog(eventlog_level_error,__FUNCTION__,"got NULL conn->protocol.loggeduser");
return 0;
}
a = accountlist_find_account(username);
if (!a) {
irc_send_cmd(conn,"NOTICE",":Authentication failed."); /* user does not exist */
return 0;
}
if (connlist_find_connection_by_account(a) && prefs_get_kick_old_login()==0) {
irc_send_cmd(conn,"NOTICE",":Authentication rejected (already logged in) ");
}
else if (account_get_auth_lock(a)==1) {
irc_send_cmd(conn,"NOTICE",":Authentication rejected (account is locked) ");
}
else
{
if((conn_get_wol(conn) == 1)) {
temphash = account_get_wol_apgar(a);
tempapgar = conn_wol_get_apgar(conn);
if(temphash == NULL) {
account_set_wol_apgar(a,tempapgar);
temphash = account_get_wol_apgar(a);
}
if(tempapgar == NULL) {
irc_send_cmd(conn,"NOTICE",":Authentication failed."); /* bad APGAR */
conn_increment_passfail_count(conn);
return 0;
}
if(strcmp(temphash,tempapgar) == 0) {
bnetd_log(username, addr_num_to_ip_str(conn_get_addr(conn)), "IRC", "LOGIN", NULL, 1, 0);
conn_login(conn,a,username);
conn_set_state(conn,conn_state_loggedin);
conn_set_clienttag(conn,CLIENTTAG_WWOL_UINT); /* WWOL hope here is ok */
return 1;
}
else {
conn_increment_passfail_count(conn);
return 0;
}
}
hash_set_str(&h1,passhash);
temphash = account_get_pass(a);
hash_set_str(&h2,temphash);
if (hash_eq(h1,h2)) {
bnetd_log(username, addr_num_to_ip_str(conn_get_addr(conn)), "IRC", "LOGIN", NULL, 1, 0);
conn_login(conn,a,username);
conn_set_state(conn,conn_state_loggedin);
conn_set_clienttag(conn,CLIENTTAG_IIRC_UINT); /* IIRC hope here is ok */
irc_send_cmd(conn,"NOTICE",":Authentication successful. You are now logged in.");
return 1;
} else {
irc_send_cmd(conn,"NOTICE",":Authentication failed."); /* wrong password */
conn_increment_passfail_count(conn);
}
}
return 0;
}
