static t_mailbox * mailbox_open(t_account * user, t_mbox_mode mode) {
t_mailbox * rez;
char * path;
char const * maildir;
rez=xmalloc(sizeof(t_mailbox));
maildir=prefs_get_maildir();
if (mode & mbox_mode_write)
p_mkdir(maildir,S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
path=xmalloc(strlen(maildir)+1+8+1);
if (maildir[0]!='\0' && maildir[strlen(maildir)-1]=='/')
sprintf(path,"%s%06u",maildir,account_get_uid(user));
else
sprintf(path,"%s/%06u",maildir,account_get_uid(user));
if (mode & mbox_mode_write)
p_mkdir(path,S_IRWXU | S_IXGRP | S_IRGRP | S_IROTH | S_IXOTH);
if ((rez->maildir=p_opendir(path))==NULL) {
if (mode & mbox_mode_write)
eventlog(eventlog_level_error,__FUNCTION__,"error opening maildir");
xfree(path);
xfree(rez);
return NULL;
}
rez->uid=account_get_uid(user);
rez->path=path;
return rez;
}
extern int bits_va_unlock_account(t_account * account)
{
if (!account)
{
eventlog(eventlog_level_error,"bits_va_unlock_account","got NULL account");
return -1;
}
if (!bits_uplink_connection)
{
eventlog(eventlog_level_error,"bits_va_unlock_account","FIXME: bits master should never (un)lock account");
return 0;
}
eventlog(eventlog_level_debug,"bits_va_unlock_account","unlocking account #%u",account_get_uid(account));
bits_va_locklist_del(bits_uplink_connection,bits_va_locklist_byuid(bits_uplink_connection,account_get_uid(account)));
if (account_get_bits_state(account)!=account_state_invalid)
{
if (!bits_va_locklist_is_locked_by(account_get_uid(account)))
{
send_bits_va_unlock(account_get_uid(account));
}
}
if (accountlist_remove_account(account)<0) eventlog(eventlog_level_error,"bits_va_unlock_account","account is not in accountlist");
account_destroy(account);
return 0;
}
static void mail_func_delete(t_connection * c, std::istream& istr)
{
if (!c) {
ERROR0("got NULL connection");
return;
}
std::string token;
istr >> token;
if (token.empty()) {
message_send_text(c,message_type_error,c,"Please specify which message to delete. Use the following syntax: /mail delete {<index>|all} .");
return;
}
t_account * user = conn_get_account(c);
Mailbox mbox(account_get_uid(user));
if (token == "all") {
mbox.clear();
message_send_text(c, message_type_info, c, "Successfully deleted messages.");
} else {
if (std::find_if(token.begin(), token.end(), NonNumericChar) != token.end()) {
message_send_text(c,message_type_error,c,"Invalid index. Please use /mail delete {<index>|all} where <index> is a number.");
return;
}
mbox.erase(std::atoi(token.c_str()));
message_send_text(c,message_type_info,c, "Succesfully deleted message.");
}
}
extern unsigned check_mail(t_connection const * c)
{
if (!c) {
ERROR0("got NULL connection");
return 0;
}
return Mailbox(account_get_uid(conn_get_account(c))).size();
}
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 t_friend * friendlist_find_uid(t_list * flist, int uid)
{
t_elem * curr;
t_friend * fr;
if(flist==NULL)
return NULL;
LIST_TRAVERSE(flist,curr)
{
if (!(fr = elem_get_data(curr)))
{
eventlog(eventlog_level_error,__FUNCTION__,"found NULL entry in list");
continue;
}
if (account_get_uid(fr->friendacc)==uid) return fr;
}
return NULL;
}
static int _handle_privmsg_command(t_connection * conn, int numparams, char ** params, char * text)
{
if ((numparams>=1)&&(text))
{
int i;
char ** e;
e = irc_get_listelems(params[0]);
/* FIXME: support wildcards! */
/* start amadeo: code was sent by some unkown fellow of pvpgn (maybe u wanna give us your name
for any credits), it adds nick-registration, i changed some things here and there... */
for (i=0; ((e)&&(e[i])); i++) {
if (strcasecmp(e[i],"NICKSERV")==0) {
char * pass;
char * p;
pass = std::strchr(text,' ');
if (pass)
*pass++ = '\0';
if (strcasecmp(text,"identify")==0) {
switch (conn_get_state(conn)) {
case conn_state_bot_password:
{
if (pass) {
t_hash h;
for (p = pass; *p; p++)
if (std::isupper((int)*p)) *p = std::tolower(*p);
bnet_hash(&h,std::strlen(pass),pass);
irc_authenticate(conn,hash_get_str(h));
}
else {
message_send_text(conn,message_type_notice,NULL,"Syntax: IDENTIFY <password> (max 16 characters)");
}
break;
}
case conn_state_loggedin:
{
message_send_text(conn,message_type_notice,NULL,"You don't need to IDENTIFY");
break;
}
default:
;
eventlog(eventlog_level_trace,__FUNCTION__,"got /msg in unexpected connection state (%s)",conn_state_get_str(conn_get_state(conn)));
}
}
else if (strcasecmp(text,"register")==0) {
unsigned int j;
t_hash passhash;
t_account * temp;
char msgtemp[MAX_IRC_MESSAGE_LEN];
char * username=(char *)conn_get_loggeduser(conn);
if (account_check_name(username)<0) {
message_send_text(conn,message_type_error,conn,"Account name contains invalid symbol!");
break;
}
if(!prefs_get_allow_new_accounts()) {
message_send_text(conn,message_type_error,conn,"Account creation is not allowed");
break;
}
if (!pass || pass[0]=='\0' || (std::strlen(pass)>16) ) {
message_send_text(conn,message_type_error,conn,"Syntax: REGISTER <password> (max 16 characters)");
break;
}
for (j=0; j<std::strlen(pass); j++)
if (std::isupper((int)pass[j])) pass[j] = std::tolower((int)pass[j]);
bnet_hash(&passhash,std::strlen(pass),pass);
snprintf(msgtemp, sizeof(msgtemp), "Trying to create account \"%s\" with password \"%s\"",username,pass);
message_send_text(conn,message_type_info,conn,msgtemp);
temp = accountlist_create_account(username,hash_get_str(passhash));
if (!temp) {
message_send_text(conn,message_type_error,conn,"Failed to create account!");
eventlog(eventlog_level_debug,__FUNCTION__,"[%d] account \"%s\" not created (failed)",conn_get_socket(conn),username);
conn_unget_chatname(conn,username);
break;
}
snprintf(msgtemp, sizeof(msgtemp), "Account "UID_FORMAT" created.",account_get_uid(temp));
message_send_text(conn,message_type_info,conn,msgtemp);
eventlog(eventlog_level_debug,__FUNCTION__,"[%d] account \"%s\" created",conn_get_socket(conn),username);
conn_unget_chatname(conn,username);
}
else {
char tmp[MAX_IRC_MESSAGE_LEN+1];
message_send_text(conn,message_type_notice,NULL,"Invalid arguments for NICKSERV");
snprintf(tmp, sizeof(tmp), ":Unrecognized command \"%s\"", text);
message_send_text(conn,message_type_notice,NULL,tmp);
}
}
else if (conn_get_state(conn)==conn_state_loggedin) {
if (e[i][0]=='#') {
/* channel message */
t_channel * channel;
if ((channel = channellist_find_channel_by_name(irc_convert_ircname(e[i]),NULL,NULL))) {
if ((std::strlen(text)>=9)&&(std::strncmp(text,"\001ACTION ",8)==0)&&(text[std::strlen(text)-1]=='\001')) {
/* at least "\001ACTION \001" */
/* it's a CTCP ACTION message */
text = text + 8;
text[std::strlen(text)-1] = '\0';
channel_message_send(channel,message_type_emote,conn,text);
}
else {
channel_message_log(channel, conn, 1, text);
channel_message_send(channel,message_type_talk,conn,text);
}
}
else {
irc_send(conn,ERR_NOSUCHCHANNEL,":No such channel");
}
}
else {
/* whisper */
t_connection * user;
if ((user = connlist_find_connection_by_accountname(e[i])))
{
message_send_text(user,message_type_whisper,conn,text);
}
else
{
irc_send(conn,ERR_NOSUCHNICK,":No such user");
}
}
}
}
if (e)
irc_unget_listelems(e);
}
else
irc_send(conn,ERR_NEEDMOREPARAMS,"PRIVMSG :Not enough parameters");
return 0;
}
static void mail_func_read(t_connection * c, std::istream& istr)
{
if (!c) {
ERROR0("got NULL connection");
return;
}
std::string token;
istr >> token;
t_account * user = conn_get_account(c);
Mailbox mbox(account_get_uid(user));
if (token.empty()) { /* user wants to see the mail summary */
if (mbox.empty()) {
message_send_text(c,message_type_info,c,"You have no mail.");
return;
}
MailList mlist;
mbox.readAll(mlist);
std::ostringstream ostr;
ostr << "You have " << mbox.size() << " messages. Your mail quote is set to " << get_mail_quota(user) << '.';
message_send_text(c, message_type_info, c, ostr.str().c_str());
message_send_text(c, message_type_info, c, "ID Sender Date");
message_send_text(c, message_type_info, c, "-------------------------------------");
for(MailList::const_iterator it(mlist.begin()); it != mlist.end(); ++it) {
ostr.str("");
ostr << std::setfill('0') << std::setw(2) << std::right << (it - mlist.begin()) << " "
<< std::setfill(' ') << std::setw(14) << std::left << it->sender() << ' ';
char buff[128];
std::strftime(buff, sizeof(buff), "%a %b %d %H:%M:%S %Y", std::localtime(&it->timestamp()));
ostr << buff;
message_send_text(c, message_type_info, c, ostr.str().c_str());
}
message_send_text(c,message_type_info,c,"Use /mail read <ID> to read the content of any message");
} else { /* user wants to read a message */
if (std::find_if(token.begin(), token.end(), NonNumericChar) != token.end()) {
message_send_text(c,message_type_error,c,"Invalid index. Please use /mail read <index> where <index> is a number.");
return;
}
try {
unsigned idx = std::atoi(token.c_str());
Mail mail(mbox.read(idx));
std::ostringstream ostr;
ostr << "Message #" << idx << " from " << mail.sender() << " on ";
char buff[128];
std::strftime(buff, sizeof(buff), "%a %b %d %H:%M:%S %Y", std::localtime(&mail.timestamp()));
ostr << buff << ':';
message_send_text(c, message_type_info, c, ostr.str().c_str());
message_send_text(c, message_type_info, c, mail.message().c_str());
} catch (const Mailbox::ReadError&) {
message_send_text(c,message_type_error,c,"There was an error completing your request.");
}
}
}
bool
LadderReferencedObject::getData(const LadderKey& ladderKey_, unsigned int& uid_, unsigned int& primary_, unsigned int& secondary_, unsigned int& tertiary_) const
{
// returns false in case of failures - and also when no need to add this referencedObject to ladder
t_clienttag clienttag = ladderKey_.getClienttag();
t_ladder_id ladderId = ladderKey_.getLadderId();
if (referenceType == referenceTypeAccount)
{
uid_ = account_get_uid(account);
if (clienttag == CLIENTTAG_WARCRAFT3_UINT || clienttag == CLIENTTAG_WAR3XP_UINT)
{
if (!(primary_ = account_get_ladder_level(account,clienttag,ladderId)))
return false;
secondary_ = account_get_ladder_xp(account,clienttag,ladderId);
tertiary_ = 0;
return true;
}else{
t_ladder_sort ladderSort = ladderKey_.getLadderSort();
unsigned int rating, wins, games;
// current ladders
if (ladderKey_.getLadderTime() == ladder_time_current)
{
rating = account_get_ladder_rating(account,clienttag,ladderId);
if (!rating) return false;
wins = account_get_ladder_wins(account,clienttag,ladderId);
games = wins +
account_get_ladder_losses(account,clienttag,ladderId)+
account_get_ladder_disconnects(account,clienttag,ladderId)+
account_get_ladder_draws(account,clienttag,ladderId);
}else{ // active ladders
rating = account_get_ladder_active_rating(account,clienttag,ladderId);
if (!rating) return false;
wins = account_get_ladder_active_wins(account,clienttag,ladderId);
games = wins +
account_get_ladder_active_losses(account,clienttag,ladderId)+
account_get_ladder_active_disconnects(account,clienttag,ladderId)+
account_get_ladder_active_draws(account,clienttag,ladderId);
}
unsigned int ratio = (wins<<10)/games;
switch (ladderSort)
{
case ladder_sort_highestrated:
primary_ = rating;
secondary_ = wins;
tertiary_ = ratio;
return true;
case ladder_sort_mostwins:
primary_ = wins;
secondary_ = rating;
tertiary_ = ratio;
return true;
case ladder_sort_mostgames:
primary_ = games;
secondary_ = rating;
tertiary_ = ratio;
return true;
default:
return false;
}
}
}
else if (referenceType == referenceTypeTeam)
{
uid_ = team_get_teamid(team);
if (!(primary_ = team_get_level(team)))
return false;
secondary_ = team_get_xp(team);
tertiary_ = 0;
return true;
}
return false;
}
