src/bnetd/clan.c

/*
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
#define CLAN_INTERNAL_ACCESS
#include "common/setup_before.h"
#include <stdio.h>
#ifdef HAVE_STDDEF_H
# include <stddef.h>
#else
# ifndef NULL
#  define NULL ((void *)0)
# endif
#endif
#ifdef STDC_HEADERS
# include <stdlib.h>
#else
# ifdef HAVE_MALLOC_H
#  include <malloc.h>
# endif
#endif
#ifdef HAVE_STRING_H
# include <string.h>
#else
# ifdef HAVE_STRINGS_H
#  include <strings.h>
# endif
#endif
#include "compat/strrchr.h"
#include "compat/strdup.h"
#include "compat/strcasecmp.h"
#include "compat/strncasecmp.h"
#include "compat/pdir.h"
#include <errno.h>
#include "compat/strerror.h"
#ifdef TIME_WITH_SYS_TIME
# include <sys/time.h>
# include <time.h>
#else
# ifdef HAVE_SYS_TIME_H
#  include <sys/time.h>
# else
#  include <time.h>
# endif
#endif
#ifdef HAVE_SYS_TYPES_H
# include <sys/types.h>
#endif
#include "common/eventlog.h"
#include "common/packet.h"
#include "common/bnet_protocol.h"
#include "common/tag.h"
#include "common/util.h"
#include "common/bnettime.h"
#include "common/eventlog.h"
#include "common/list.h"
#include "common/proginfo.h"
#include "common/bn_type.h"
#include "common/xalloc.h"
#include "connection.h"
#include "anongame.h"
#include "prefs.h"
#include "friends.h"
#include "game.h"
#include "clan.h"
#include "account.h"
#include "channel.h"
#include "anongame.h"
#include "storage.h"
#include "server.h"
#include "compat/uint.h"
#include "common/setup_after.h"

static t_list *clanlist_head = NULL;
int max_clanid = 0;

/* callback function for storage use */

static int _cb_load_clans(void *clan)
{
    if (clanlist_add_clan(clan) < 0)
    {
        eventlog(eventlog_level_error, __FUNCTION__, "failed to add clan to clanlist");
        return -1;
    }

    if (((t_clan *) clan)->clanid > max_clanid)
        max_clanid = ((t_clan *) clan)->clanid;
    return 0;
}

/*
** Packet Management
*/

extern int clan_send_packet_to_online_members(t_clan * clan, t_packet * packet)
{
    t_elem *curr;

    if (!clan)
    {
        eventlog(eventlog_level_error, __FUNCTION__, "got NULL clan");
        return -1;
    }

    if (!packet)
    {
        eventlog(eventlog_level_error, __FUNCTION__, "got NULL packet");
        return -1;
    }

    LIST_TRAVERSE(clan->members, curr)
    {
        t_clanmember *  member;
        t_clienttag     clienttag;
        t_connection *  conn;
        
        if (!(member = elem_get_data(curr)))
        {
                eventlog(eventlog_level_error,__FUNCTION__,"got NULL elem in list");
                continue;
        }
        if (!(conn = clanmember_get_conn(member)))
                continue;                               // not online
                
        if (!(clienttag = conn_get_clienttag(conn)))
        {
                eventlog(eventlog_level_error,__FUNCTION__,"conn has NULL clienttag");
                continue;
        }

        if ((clienttag !=  CLIENTTAG_WARCRAFT3_UINT ) && (clienttag != CLIENTTAG_WAR3XP_UINT))
                continue;                               // online but wrong client
                
        conn_push_outqueue(conn, packet);
    }

    return 0;
}

extern int clan_send_status_window_on_create(t_clan * clan)
{
    t_packet * rpacket;
    t_elem *curr;

    if (!(clan))
    {
        eventlog(eventlog_level_error, __FUNCTION__, "got NULL clan");
        return -1;
    }

    if ((rpacket = packet_create(packet_class_bnet)))
    {
        char channelname[10];
        if (clan->clantag)
            sprintf(channelname, "Clan %c%c%c%c", (clan->clantag >> 24), (clan->clantag >> 16) & 0xff, (clan->clantag >> 8) & 0xff, clan->clantag & 0xff);
        else
        {
            sprintf(channelname, "Clans");
            eventlog(eventlog_level_error,__FUNCTION__,"clan has NULL clantag");
        }
            
        packet_set_size(rpacket, sizeof(t_server_w3xp_clan_clanack));
        packet_set_type(rpacket, SERVER_W3XP_CLAN_CLANACK);
        bn_byte_set(&rpacket->u.server_w3xp_clan_clanack.unknow1, 0);
        bn_int_set(&rpacket->u.server_w3xp_clan_clanack.clantag, clan->clantag);
        
        LIST_TRAVERSE(clan->members, curr)
        {
            t_clanmember *      member;
            t_clienttag         clienttag;
            t_connection *      conn;
            
            if (!(member = elem_get_data(curr)))
            {
                eventlog(eventlog_level_error,__FUNCTION__,"got NULL elem in list");
                continue;
            }
            if (!(conn = clanmember_get_conn(member)))
                continue;                       // not online;
                
            if (!(clienttag = conn_get_clienttag(conn)))
            {
                eventlog(eventlog_level_error,__FUNCTION__,"conn has NULL clienttag");
                continue;
            }
            if ((clienttag != CLIENTTAG_WARCRAFT3_UINT) && (clienttag != CLIENTTAG_WAR3XP_UINT))
                continue;                       // online but wrong client
                
            if (conn_get_channel(conn))
            {
                conn_update_w3_playerinfo(conn);
                channel_set_userflags(conn);
                if (conn_set_channel(conn, channelname) < 0)
                    conn_set_channel(conn, CHANNEL_NAME_BANNED);        /* should not fail */
            }
            bn_byte_set(&rpacket->u.server_w3xp_clan_clanack.status, member->status);
            conn_push_outqueue(conn, rpacket);
        }
        packet_del_ref(rpacket);
    }
    return 0;
}

extern int clan_close_status_window_on_disband(t_clan * clan)
{
    t_packet * rpacket;
    t_elem *curr;

    if (!(clan))
    {
        eventlog(eventlog_level_error, __FUNCTION__, "got NULL clan");
        return -1;
    }

    if ((rpacket = packet_create(packet_class_bnet)))
    {
        packet_set_size(rpacket, sizeof(t_server_w3xp_clanquitnotify));
        packet_set_type(rpacket, SERVER_W3XP_CLANQUITNOTIFY);
        bn_byte_set(&rpacket->u.server_w3xp_clan_clanack.status, SERVER_W3XP_CLANQUITNOTIFY_STATUS_REMOVED_FROM_CLAN);
        LIST_TRAVERSE(clan->members, curr)
        {
            t_clanmember *      member;
            t_clienttag         clienttag;
            t_connection *      conn;
            
            if (!(member = elem_get_data(curr)))
            {
                eventlog(eventlog_level_error,__FUNCTION__,"got NULL elem in list");
                continue;
            }
            if (!(conn = clanmember_get_conn(member)))
                continue;                       // not online;
                
            if (!(clienttag = conn_get_clienttag(conn)))
            {
                eventlog(eventlog_level_error,__FUNCTION__,"conn has NULL clienttag");
                continue;
            }

            if ((clienttag != CLIENTTAG_WARCRAFT3_UINT) && (clienttag != CLIENTTAG_WAR3XP_UINT))
                continue;                       // online but wrong client
                
            conn_push_outqueue(conn, rpacket);
            conn_update_w3_playerinfo(conn);
        }
        packet_del_ref(rpacket);
    }


    return 0;
}

extern int clan_send_status_window(t_connection * c)
{
    t_packet * rpacket;
    t_account *acc;
    t_clanmember *member;
    t_clienttag clienttag;
    t_clan * clan;

    if (!(acc = conn_get_account(c)))
        return 0;

    if (!(member = account_get_clanmember(acc)))
        return 0;

    if (!(clan = member->clan))
    {
        eventlog(eventlog_level_error,__FUNCTION__,"member has NULL clan");
        return -1;
    }

    if (!(clan->clantag))
    {
        eventlog(eventlog_level_error,__FUNCTION__,"clan has NULL clantag");
        return -1;
    }
    
    if (!(clienttag = conn_get_clienttag(c)))
    {
        eventlog(eventlog_level_error,__FUNCTION__,"conn has NULL clienttag");
        return -1;
    }
    
    if ((clienttag != CLIENTTAG_WARCRAFT3_UINT) && (clienttag != CLIENTTAG_WAR3XP_UINT))
        return 0;
        
    if ((rpacket = packet_create(packet_class_bnet)))
    {
            packet_set_size(rpacket, sizeof(t_server_w3xp_clan_clanack));
            packet_set_type(rpacket, SERVER_W3XP_CLAN_CLANACK);
            bn_byte_set(&rpacket->u.server_w3xp_clan_clanack.unknow1, 0);
            bn_int_set(&rpacket->u.server_w3xp_clan_clanack.clantag, member->clan->clantag);
            bn_byte_set(&rpacket->u.server_w3xp_clan_clanack.status, member->status);
            conn_push_outqueue(c, rpacket);
            packet_del_ref(rpacket);
    }
    return 0;
}

extern int clan_close_status_window(t_connection * c)
{
    t_packet * rpacket;
    t_clienttag clienttag;

    if (!(clienttag = conn_get_clienttag(c)))
    {
        eventlog(eventlog_level_error,__FUNCTION__,"conn has NULL clienttag");
        return -1;
    }
    
    if ((clienttag != CLIENTTAG_WARCRAFT3_UINT) && (clienttag != CLIENTTAG_WAR3XP_UINT))
        return 0;
        
    if ((rpacket = packet_create(packet_class_bnet)))
    {
        packet_set_size(rpacket, sizeof(t_server_w3xp_clanquitnotify));
        packet_set_type(rpacket, SERVER_W3XP_CLANQUITNOTIFY);
        bn_byte_set(&rpacket->u.server_w3xp_clanquitnotify.status, SERVER_W3XP_CLANQUITNOTIFY_STATUS_REMOVED_FROM_CLAN);
        conn_push_outqueue(c, rpacket);
        packet_del_ref(rpacket);
    }
    return 0;
}

extern int clan_send_memberlist(t_connection * c, t_packet const *const packet)
{
    t_packet * rpacket;
    t_elem *curr;
    char const *username;
    t_clanmember *member;
    t_clan *clan;
    t_account *account;
    int count = 0;
    char tmpstr[2];
    const char *append_str;

    if (!(account = conn_get_account(c)))
        return -1;

    if (!(clan = account_get_clan(account)))
        return -1;

    if ((rpacket = packet_create(packet_class_bnet)))
    {
        t_account * memberacc;
        
        packet_set_size(rpacket, sizeof(t_server_w3xp_clanmemberlist_reply));
        packet_set_type(rpacket, SERVER_W3XP_CLANMEMBERLIST_REPLY);
        bn_int_set(&rpacket->u.server_w3xp_clanmemberlist_reply.count, 
                   bn_int_get(packet->u.client_w3xp_clanmemberlist_req.count));
        LIST_TRAVERSE(clan->members, curr)
        {
            if (!(member = elem_get_data(curr)))
            {
                eventlog(eventlog_level_error, __FUNCTION__, "got NULL element in list");
                continue;
            }

            if (!(memberacc = member->memberacc))
            {
                eventlog(eventlog_level_error,__FUNCTION__,"member has NULL account");
                continue;
            }

            username = account_get_name(memberacc);
            packet_append_string(rpacket, username);
            tmpstr[0] = member->status;
            append_str = clanmember_get_online_status(member, &tmpstr[1]);
            packet_append_data(rpacket, tmpstr, 2);
            if (append_str)
                packet_append_string(rpacket, append_str);
            else
                packet_append_string(rpacket, "");
            count++;
        }
        bn_byte_set(&rpacket->u.server_w3xp_clanmemberlist_reply.member_count, count);
        conn_push_outqueue(c, rpacket);
        packet_del_ref(rpacket);
        return 0;
    }

    return -1;
}

extern int clan_save_motd_chg(t_connection * c, t_packet const *const packet)
{
    t_account *account;
    char const *motd;
    int offset;
    t_clan *clan;

    if ((account = conn_get_account(c)) == NULL)
        return -1;
    if ((clan = account_get_clan(account)) == NULL)
        return -1;
    offset = sizeof(packet->u.client_w3xp_clan_motdchg);
    motd = packet_get_str_const(packet, offset, 25);
    eventlog(eventlog_level_trace, __FUNCTION__, "[%d] got W3XP_CLAN_MOTDCHG packet : %s", conn_get_socket(c), motd);
    if (clan_set_motd(clan, motd) != 0)
    {
        eventlog(eventlog_level_error, __FUNCTION__, "Failed to set clan motd.");
        return -1;
    }
    clan->modified = 1;
    return 0;
}


extern int clan_send_motd_reply(t_connection * c, t_packet const *const packet)
{
    t_packet * rpacket;
    t_account *account;
    t_clan *clan;

    if ((account = conn_get_account(c)) == NULL)
        return -1;
    if ((clan = account_get_clan(account)) == NULL)
        return -1;
    if (clan->clan_motd == NULL)
    {
        eventlog(eventlog_level_error, __FUNCTION__, "Failed to get clan motd.");
        return -1;
    }
    if ((rpacket = packet_create(packet_class_bnet)))
    {
        packet_set_size(rpacket, sizeof(t_server_w3xp_clan_motdreply));
        packet_set_type(rpacket, SERVER_W3XP_CLAN_MOTDREPLY);
        bn_int_set(&rpacket->u.server_w3xp_clan_motdreply.count, bn_int_get(packet->u.client_w3xp_clan_motdreq.count));
        bn_int_set(&rpacket->u.server_w3xp_clan_motdreply.unknow1, SERVER_W3XP_CLAN_MOTDREPLY_UNKNOW1);
        packet_append_string(rpacket, clan->clan_motd);
        conn_push_outqueue(c, rpacket);
        packet_del_ref(rpacket);
    }

    return 0;
}

/*
** String / Function Management
*/

extern int clan_get_possible_member(t_connection * c, t_packet const *const packet)
{
    t_packet * rpacket;
    t_channel *channel;
    t_connection *conn;
    char const *username;
    t_account * account;

    int friend_count = 0;
    int clantag;
    clantag = bn_int_get(packet->u.client_w3xp_clan_createreq.clantag);
    if ((rpacket = packet_create(packet_class_bnet)) == NULL)
    {
        return -1;
    }
    packet_set_size(rpacket, sizeof(t_server_w3xp_clan_createreply));
    packet_set_type(rpacket, SERVER_W3XP_CLAN_CREATEREPLY);
    bn_int_set(&rpacket->u.server_w3xp_clan_createreply.count, bn_int_get(packet->u.client_w3xp_clan_createreq.count));
    if (clanlist_find_clan_by_clantag(clantag) != NULL)
    {
        bn_byte_set(&rpacket->u.server_w3xp_clan_createreply.check_result, SERVER_W3XP_CLAN_CREATEREPLY_CHECK_ALLREADY_IN_USE);
        bn_byte_set(&rpacket->u.server_w3xp_clan_createreply.friend_count, 0);
        conn_push_outqueue(c, rpacket);
        packet_del_ref(rpacket);
        return 0;
    }
    if ((account = conn_get_account(c)) && (account_get_clan(account) != NULL || account_get_creating_clan(account) != NULL))
    {
        bn_byte_set(&rpacket->u.server_w3xp_clan_createreply.check_result, SERVER_W3XP_CLAN_CREATEREPLY_CHECK_EXCEPTION);
        bn_byte_set(&rpacket->u.server_w3xp_clan_createreply.friend_count, 0);
        conn_push_outqueue(c, rpacket);
        packet_del_ref(rpacket);
        return 0;
    }
    bn_byte_set(&rpacket->u.server_w3xp_clan_createreply.check_result, SERVER_W3XP_CLAN_CREATEREPLY_CHECK_OK);
    channel = conn_get_channel(c);
    if (channel_get_permanent(channel))
    {
        /* If not in a private channel, retreive number of mutual friend connected */
        t_list *flist = account_get_friends(conn_get_account(c));
        t_elem const *curr;
        t_friend *fr;

        LIST_TRAVERSE_CONST(flist, curr)
        {
            if ((fr = elem_get_data(curr)) != NULL)
            {
                t_account *fr_acc = friend_get_account(fr);
                t_clienttag clienttag;
                if (fr->mutual 
                    && ((conn = connlist_find_connection_by_account(fr_acc)) != NULL) 
                    && (conn_get_channel(conn) == channel) 
                    && (!account_get_clan(fr_acc)) 
                    && (!account_get_creating_clan(fr_acc)) 
                    && (clienttag = conn_get_clienttag(conn)) 
                    && ((clienttag == CLIENTTAG_WAR3XP_UINT) || (clienttag ==  CLIENTTAG_WARCRAFT3_UINT)) 
                    && (username = account_get_name(fr_acc)))
                {
                    friend_count++;
                    packet_append_string(rpacket, username);
                }
            }
        }
    } else
    {
        /* If in a private channel, retreive all users in the channel */
        for (conn = channel_get_first(channel); conn; conn = channel_get_next())
        {
            if ((conn != c) && (username = conn_get_username(conn)))
            {
                friend_count++;
                packet_append_string(rpacket, username);
            }
        }
    }
    bn_byte_set(&rpacket->u.server_w3xp_clan_createreply.friend_count, friend_count);
    conn_push_outqueue(c, rpacket);
    packet_del_ref(rpacket);

    return 0;
}

extern int clanmember_on_change_status(t_clanmember * member)
{
    t_packet * rpacket;
    if (member == NULL)
    {
        eventlog(eventlog_level_error, __FUNCTION__, "got NULL clanmember");
        return -1;
    }
    if (member->clan == NULL)
    {
        eventlog(eventlog_level_error, __FUNCTION__, "got NULL clan");
        return -1;
    }
    if ((rpacket = packet_create(packet_class_bnet)) != NULL)
    {
        char tmpstr[2];
        const char *append_str;
        packet_set_size(rpacket, sizeof(t_server_w3xp_clanmemberupdate));
        packet_set_type(rpacket, SERVER_W3XP_CLANMEMBERUPDATE);
        packet_append_string(rpacket, account_get_name(member->memberacc));
        tmpstr[0] = member->status;
        append_str = clanmember_get_online_status(member, &tmpstr[1]);
        packet_append_data(rpacket, tmpstr, 2);
        if (append_str)
            packet_append_string(rpacket, append_str);
        else
            packet_append_string(rpacket, "");
        clan_send_packet_to_online_members(member->clan, rpacket);
        packet_del_ref(rpacket);
    }
    return 0;
}

extern int clanmember_on_change_status_by_connection(t_connection * conn)
{
    t_packet * rpacket;
    t_account *acc;
    t_clanmember *member;
    if (!(conn))
    {
        eventlog(eventlog_level_error, __FUNCTION__, "got NULL conn");
        return -1;
    }
    if ((acc = conn_get_account(conn)) == NULL)
        return -1;
    if ((member = account_get_clanmember(acc)) == NULL)
        return -1;
    if (member->clan == NULL)
        return -1;
    if ((rpacket = packet_create(packet_class_bnet)) != NULL)
    {
        char tmpstr[2];
        const char *append_str;
        packet_set_size(rpacket, sizeof(t_server_w3xp_clanmemberupdate));
        packet_set_type(rpacket, SERVER_W3XP_CLANMEMBERUPDATE);
        packet_append_string(rpacket, account_get_name(acc));
        tmpstr[0] = member->status;
        append_str = clanmember_get_online_status_by_connection(conn, &tmpstr[1]);
        packet_append_data(rpacket, tmpstr, 2);
        if (append_str)
            packet_append_string(rpacket, append_str);
        else
            packet_append_string(rpacket, "");
        clan_send_packet_to_online_members(member->clan, rpacket);
        packet_del_ref(rpacket);
    }
    return 0;
}

extern int clan_unload_members(t_clan * clan)
{
    t_elem *curr;
    t_clanmember *member;

    if (clan->members)
    {
        LIST_TRAVERSE(clan->members, curr)
        {
            if (!(member = elem_get_data(curr)))
            {
                eventlog(eventlog_level_error, __FUNCTION__, "found NULL entry in list");
                continue;
            }
            list_remove_elem(clan->members, &curr);
            xfree((void *) member);
        }

        if (list_destroy(clan->members) < 0)
            return -1;

        clan->members = NULL;
    }

    return 0;
}

extern int clan_remove_all_members(t_clan * clan)
{
    t_elem *curr;
    t_clanmember *member;

    if (clan->members)
    {
        LIST_TRAVERSE(clan->members, curr)
        {
            if (!(member = elem_get_data(curr)))
            {
                eventlog(eventlog_level_error, __FUNCTION__, "found NULL entry in list");
                continue;
            }
            if (member->memberacc != NULL)
                account_set_clanmember(member->memberacc, NULL);
            list_remove_elem(clan->members, &curr);
            xfree((void *) member);
        }

        if (list_destroy(clan->members) < 0)
            return -1;

        clan->members = NULL;
    }

    return 0;
}

extern int clanlist_remove_clan(t_clan * clan)
{
    t_elem * elem;
    if (clan == NULL)
    {
        eventlog(eventlog_level_error, __FUNCTION__, "get NULL clan");
        return -1;
    }
    if (list_remove_data(clanlist_head, clan, &elem) < 0)
    {
        eventlog(eventlog_level_error, __FUNCTION__, "could not delete clan entry");
        return -1;
    }
    return 0;
}

extern int clan_remove(int clantag)
{
    return storage->remove_clan(clantag);
}

extern int clan_save(t_clan * clan)
{
    if (clan->created <= 0)
    {
        if (now - clan->creation_time > 120)
        {
            clanlist_remove_clan(clan);
            clan_destroy(clan);
        }
        return 0;
    }

    storage->write_clan(clan);

    clan->modified = 0;

    return 0;
}

extern t_list *clanlist(void)
{
    return clanlist_head;
}

extern int clanlist_add_clan(t_clan * clan)
{
    if (!(clan))
    {
        eventlog(eventlog_level_error, __FUNCTION__, "got NULL clan");
        return -1;
    }

    if (!(clan->clanid))
        clan->clanid = ++max_clanid;

    list_append_data(clanlist_head, clan);

    return clan->clanid;
}

int clanlist_load(void)
{
    // make sure to unload previous clanlist before loading again
    if (clanlist_head)
        clanlist_unload();

    clanlist_head = list_create();

    storage->load_clans(_cb_load_clans);

    return 0;
}

extern int clanlist_save(void)
{
    t_elem *curr;
    t_clan *clan;

    if (clanlist_head)
    {
        LIST_TRAVERSE(clanlist_head, curr)
        {
            if (!(clan = elem_get_data(curr)))
            {
                eventlog(eventlog_level_error, __FUNCTION__, "found NULL entry in list");
                continue;
            }
            if (clan->modified)
                clan_save(clan);
        }

    }

    return 0;
}

extern int clanlist_unload(void)
{
    t_elem *curr;
    t_clan *clan;

    if (clanlist_head)
    {
        LIST_TRAVERSE(clanlist_head, curr)
        {
            if (!(clan = elem_get_data(curr)))
            {
                eventlog(eventlog_level_error, __FUNCTION__, "found NULL entry in list");
                continue;
            }
            if (clan->clanname)
                xfree((void *) clan->clanname);
            if (clan->clan_motd)
                xfree((void *) clan->clan_motd);
            clan_unload_members(clan);
            xfree((void *) clan);
            list_remove_elem(clanlist_head, &curr);
        }

        if (list_destroy(clanlist_head) < 0)
            return -1;

        clanlist_head = NULL;
    }

    return 0;
}

extern t_clan *clanlist_find_clan_by_clanid(int cid)
{
    t_elem *curr;
    t_clan *clan;

    if (clanlist_head)
    {
        LIST_TRAVERSE(clanlist_head, curr)
        {
            if (!(clan = elem_get_data(curr)))
            {
                eventlog(eventlog_level_error, __FUNCTION__, "found NULL entry in list");
                continue;
            }
            eventlog(eventlog_level_error, __FUNCTION__, "trace %d", clan->clanid);
            if (clan->created && (clan->clanid == cid))
                return clan;
        }

    }

    return NULL;
}

extern t_clan *clanlist_find_clan_by_clantag(int clantag)
{
    t_elem *curr;
    t_clan *clan;

    if (clantag == 0)
        return NULL;
    if (clanlist_head)
    {
        LIST_TRAVERSE(clanlist_head, curr)
        {
            if (!(clan = elem_get_data(curr)))
            {
                eventlog(eventlog_level_error, __FUNCTION__, "found NULL entry in list");
                continue;
            }
            if (clan->created && (clan->clantag == clantag))
                return clan;
        }

    }

    return NULL;
}

extern t_clanmember *clan_find_member(t_clan * clan, t_account * memberacc)
{
    t_clanmember *member;
    t_elem *curr;
    if (!(clan))
    {
        eventlog(eventlog_level_error, __FUNCTION__, "got NULL clan");
        return NULL;
    }
    if (!(clan->members))
    {
        eventlog(eventlog_level_error, __FUNCTION__, "found NULL clan->members");
        return NULL;
    }
    LIST_TRAVERSE(clan->members, curr)
    {
        if (!(member = elem_get_data(curr)))
        {
            eventlog(eventlog_level_error, __FUNCTION__, "got NULL element in list");
            return NULL;
        }
        if (member->memberacc == memberacc)
            return member;
    }

    return NULL;
}

extern t_clanmember *clan_find_member_by_name(t_clan * clan, char const *membername)
{
    t_clanmember *member;
    t_elem *curr;
    if (!(clan))
    {
        eventlog(eventlog_level_error, __FUNCTION__, "got NULL clan");
        return NULL;
    }
    if (!(clan->members))
    {
        eventlog(eventlog_level_error, __FUNCTION__, "found NULL clan->members");
        return NULL;
    }
    LIST_TRAVERSE(clan->members, curr)
    {
        if (!(member = elem_get_data(curr)))
        {
            eventlog(eventlog_level_error, __FUNCTION__, "got NULL element in list");
            return NULL;
        }
        if (strcasecmp(account_get_name(member->memberacc), membername) == 0)
            return member;
    }

    return NULL;
}

extern t_clanmember *clan_find_member_by_uid(t_clan * clan, unsigned int memberuid)
{
    t_clanmember *member;
    t_elem *curr;
    if (!(clan))
    {
        eventlog(eventlog_level_error, __FUNCTION__, "got NULL clan");
        return NULL;
    }
    if (!(clan->members))
    {
        eventlog(eventlog_level_error, __FUNCTION__, "found NULL clan->members");
        return NULL;
    }
    LIST_TRAVERSE(clan->members, curr)
    {
        if (!(member = elem_get_data(curr)))
        {
            eventlog(eventlog_level_error, __FUNCTION__, "got NULL element in list");
            return NULL;
        }
        if (account_get_uid(member->memberacc) == memberuid)
            return member;
    }

    return NULL;
}

extern t_account *clanmember_get_account(t_clanmember * member)
{
    if (!(member))
    {
        eventlog(eventlog_level_error, __FUNCTION__, "got NULL clanmember");
        return NULL;
    }

    return (t_account *) member->memberacc;
}

extern int clanmember_set_account(t_clanmember * member, t_account * memberacc)
{
    if (!(member))
    {
        eventlog(eventlog_level_error, __FUNCTION__, "got NULL clanmember");
        return -1;
    }

    member->memberacc = memberacc;
    return 0;
}

extern t_connection *clanmember_get_conn(t_clanmember * member)
{
    t_account * account;
    
    if (!(member))
    {
        eventlog(eventlog_level_error, __FUNCTION__, "got NULL clanmember");
        return NULL;
    }

    if (!(account = member->memberacc))
    {
        eventlog(eventlog_level_error,__FUNCTION__,"member as NULL account");
        return NULL;
    }

    return account_get_conn(account);
}

extern char clanmember_get_status(t_clanmember * member)
{
    if (!(member))
    {
        eventlog(eventlog_level_error, __FUNCTION__, "got NULL clanmember");
        return 0;
    }

    if ((member->status == CLAN_NEW) && (now - member->join_time > prefs_get_clan_newer_time() * 3600))
    {
        member->status = CLAN_PEON;
        member->clan->modified = 1;
#ifdef WITH_SQL
        member->modified = 1;
#endif
    }

    return member->status;
}

extern int clanmember_set_status(t_clanmember * member, char status)
{
    if (!(member))
    {
        eventlog(eventlog_level_error, __FUNCTION__, "got NULL clanmember");
        return -1;
    }

    if (member->status != status)
    {
        member->status = status;
        member->clan->modified = 1;
#ifdef WITH_SQL
        member->modified = 1;
#endif
    }
    return 0;
}

extern time_t clanmember_get_join_time(t_clanmember * member)
{
    if (!(member))
    {
        eventlog(eventlog_level_error, __FUNCTION__, "got NULL clanmember");
        return 0;
    }

    return member->join_time;
}

extern t_clan *clanmember_get_clan(t_clanmember * member)
{
    if (!(member))
    {
        eventlog(eventlog_level_error, __FUNCTION__, "got NULL clanmember");
        return 0;
    }

    return member->clan;
}

extern const char *clanmember_get_online_status(t_clanmember * member, char *status)
{
        return clanmember_get_online_status_by_connection(clanmember_get_conn(member), status);
}

extern const char *clanmember_get_online_status_by_connection(t_connection * conn, char *status)
{
    if (conn && (conn_get_state(conn)!=conn_state_empty))
    {
        t_game *game;
        t_channel *channel;
        if ((game = conn_get_game(conn)) != NULL)
        {
            if (game_get_flag(game) == game_flag_private)
                (*status) = SERVER_W3XP_CLAN_MEMBER_PRIVATE_GAME;
            else
                (*status) = SERVER_W3XP_CLAN_MEMBER_GAME;
            return game_get_name(game);
        }
        if ((channel = conn_get_channel(conn)) != NULL)
        {
            (*status) = SERVER_W3XP_CLAN_MEMBER_CHANNEL;
            return channel_get_name(channel);
        }

        (*status) = SERVER_W3XP_CLAN_MEMBER_ONLINE;
    } else
        (*status) = SERVER_W3XP_CLAN_MEMBER_OFFLINE;
    return NULL;
}

extern int clanmember_set_online(t_connection * c)
{
    t_clanmember *member;
    t_account *acc;

    if (!c)
    {
        eventlog(eventlog_level_error, __FUNCTION__, "got NULL connection");
        return -1;
    }

    if ((acc = conn_get_account(c)) && (member = account_get_clanmember(acc)))
    {
        clanmember_on_change_status(member);
    }

    return 0;
}

extern int clanmember_set_offline(t_connection * c)
{
    t_clanmember *member;
    t_account *acc;

    if (!c)
    {
        eventlog(eventlog_level_error, __FUNCTION__, "got NULL connection");
        return -1;
    }

    if ((acc = conn_get_account(c)) && (member = account_get_clanmember_forced(acc)))
    {
        clanmember_on_change_status(member);
    }

    return 0;
}

extern int clan_get_created(t_clan * clan)
{
    if (!(clan))
    {
        eventlog(eventlog_level_error, __FUNCTION__, "got NULL clan");
        return -1;
    }

    return clan->created;
}

extern int clan_set_created(t_clan * clan, int created)
{
    if (!(clan))
    {
        eventlog(eventlog_level_error, __FUNCTION__, "got NULL clan");
        return -1;
    }

    clan->created = created;

    return 0;
}

extern char clan_get_modified(t_clan * clan)
{
    if (!(clan))
    {
        eventlog(eventlog_level_error, __FUNCTION__, "got NULL clan");
        return -1;
    }

    return clan->modified;
}

extern int clan_set_modified(t_clan * clan, char modified)
{
    if (!(clan))
    {
        eventlog(eventlog_level_error, __FUNCTION__, "got NULL clan");
        return -1;
    }

    clan->modified = modified;

    return 0;
}

extern char clan_get_channel_type(t_clan * clan)
{
    if (!(clan))
    {
        eventlog(eventlog_level_error, __FUNCTION__, "got NULL clan");
        return -1;
    }

    return clan->channel_type;
}

extern int clan_set_channel_type(t_clan * clan, char channel_type)
{
    if (!(clan))
    {
        eventlog(eventlog_level_error, __FUNCTION__, "got NULL clan");
        return -1;
    }

    clan->channel_type = channel_type;

    return 0;
}

extern t_list *clan_get_members(t_clan * clan)
{
    if (!(clan))
    {
        eventlog(eventlog_level_error, __FUNCTION__, "got NULL clan");
        return NULL;
    }

    return clan->members;
}

extern char const *clan_get_name(t_clan * clan)
{
    if (!(clan))
    {
        eventlog(eventlog_level_error, __FUNCTION__, "got NULL clan");
        return NULL;
    }

    return clan->clanname;
}

extern int clan_get_clantag(t_clan * clan)
{
    if (!(clan))
    {
        eventlog(eventlog_level_error, __FUNCTION__, "got NULL clan");
        return 0;
    }

    return clan->clantag;
}

extern char const *clan_get_motd(t_clan * clan)
{
    if (!(clan))
    {
        eventlog(eventlog_level_error, __FUNCTION__, "got NULL clan");
        return NULL;
    }

    return clan->clan_motd;
}

extern int clan_set_motd(t_clan * clan, const char *motd)
{
    if (!(clan))
    {
        eventlog(eventlog_level_error, __FUNCTION__, "got NULL clan");
        return -1;
    }
    if (!(motd))
    {
        eventlog(eventlog_level_error, __FUNCTION__, "got NULL motd");
        return -1;
    } else
    {
        if (clan->clan_motd)
            xfree((void *) clan->clan_motd);
        clan->clan_motd = xstrdup(motd);
    }
    return 0;
}

extern unsigned int clan_get_clanid(t_clan * clan)
{
    if (!(clan))
    {
        eventlog(eventlog_level_error, __FUNCTION__, "got NULL clan");
        return -1;
    }

    return clan->clanid;
}

extern int clan_set_creation_time(t_clan * clan, time_t c_time)
{
    if (!(clan))
    {
        eventlog(eventlog_level_error, __FUNCTION__, "got NULL clan");
        return -1;
    }

    clan->creation_time = c_time;

    return 0;
}

extern time_t clan_get_creation_time(t_clan * clan)
{
    if (!(clan))
    {
        eventlog(eventlog_level_error, __FUNCTION__, "got NULL clan");
        return 0;
    }

    return clan->creation_time;
}

extern t_clanmember *clan_add_member(t_clan * clan, t_account * memberacc, char status)
{
    t_clanmember *member;

    if (!(clan))
    {
        eventlog(eventlog_level_error, __FUNCTION__, "got NULL clan");
        return NULL;
    }

    if (!(clan->members))
    {
        eventlog(eventlog_level_error, __FUNCTION__, "found NULL clan->members");
        return NULL;
    }

    member = xmalloc(sizeof(t_clanmember));
    member->memberacc = memberacc;
    member->status = status;
    member->join_time = now;
    member->clan = clan;
#ifdef WITH_SQL
    member->modified = 1;
#endif

    list_append_data(clan->members, member);

    account_set_clanmember(memberacc, member);

    clan->modified = 1;

    return member;
}

extern int clan_remove_member(t_clan * clan, t_clanmember * member)
{
    t_elem * elem;
    
    if (!member)
        return -1;
    if (list_remove_data(clan->members, member, &elem) < 0)
    {
        eventlog(eventlog_level_error, __FUNCTION__, "could not remove member");
        return -1;
    }
    if (member->memberacc != NULL)
    {
        account_set_clanmember(member->memberacc, NULL);
        storage->remove_clanmember(account_get_uid(member->memberacc));
    }
    xfree((void *) member);
    clan->modified = 1;
    return 0;
}

extern t_clan *clan_create(t_account * chieftain_acc, int clantag, const char *clanname, const char *motd)
{
    t_clan *clan;
    t_clanmember *member;

    clan = xmalloc(sizeof(t_clan));
    member = xmalloc(sizeof(t_clanmember));

    if (!(clanname))
    {
        eventlog(eventlog_level_error, __FUNCTION__, "got NULL clanname");
        xfree((void *) clan);
        xfree((void *) member);
        return NULL;
    }

    clan->clanname = xstrdup(clanname);

    if (!(motd))
        clan->clan_motd = xstrdup("This is a newly created clan");
    else
        clan->clan_motd = xstrdup(motd);

    clan->creation_time = now;
    clan->clantag = clantag;
    clan->clanid = ++max_clanid;
    clan->created = 0;
    clan->modified = 1;
    clan->channel_type = prefs_get_clan_channel_default_private();

    clan->members = list_create();

    member->memberacc = chieftain_acc;
    member->status = CLAN_CHIEFTAIN;
    member->join_time = clan->creation_time;
    member->clan = clan;
#ifdef WITH_SQL
    member->modified = 1;
#endif

    list_append_data(clan->members, member);

    account_set_clanmember(chieftain_acc, member);

    return clan;
}

extern int clan_destroy(t_clan * clan)
{
    if (!clan)
        return 0;
    if (clan->clanname)
        xfree((void *) clan->clanname);
    if (clan->clan_motd)
        xfree((void *) clan->clan_motd);
    clan_remove_all_members(clan);
    xfree((void *) clan);
    return 0;
}

extern int clan_get_member_count(t_clan * clan)
{
    t_elem *curr;
    int count = 0;
    LIST_TRAVERSE(clan->members, curr)
    {
        if ((elem_get_data(curr)) != NULL)
            count++;
    }
    return count;
}

extern int str_to_clantag(const char *str)
{
    int clantag = 0;

    if (!str)
        return 0;

    if (str[0])
    {
        clantag = str[0] << 24;
        if (str[1])
        {
            clantag += str[1] << 16;
            if (str[2])
            {
                clantag += str[2] << 8;
                if (str[3])
                    clantag += str[3];
            }
        }
    }
    return clantag;

}
webmaster@leafok.com	ViewVC Help
Powered by ViewVC 1.3.0-beta1