account_wrap.c

打魔兽战网的都知道他是什么

    char clienttag_str[5];
    
    if (!clienttag)
    {
	eventlog(eventlog_level_error,__FUNCTION__,"got bad clienttag");
	return -1;
    }
    sprintf(key,"Record\\%s\\0\\vitality",tag_uint_to_str(clienttag_str,clienttag));
    return account_set_numattr(account,key,vitality);
}


extern unsigned int account_get_normal_gold(t_account * account, t_clienttag clienttag)
{
    char key[256];
    char clienttag_str[5];
    
    if (!clienttag)
    {
	eventlog(eventlog_level_error,__FUNCTION__,"got bad clienttag");
	return 0;
    }
    sprintf(key,"Record\\%s\\0\\gold",tag_uint_to_str(clienttag_str,clienttag));
    return account_get_numattr(account,key);
}


extern int account_set_normal_gold(t_account * account, t_clienttag clienttag, unsigned int gold)
{
    char key[256];
    char clienttag_str[5];
    
    if (!clienttag)
    {
	eventlog(eventlog_level_error,__FUNCTION__,"got bad clienttag");
	return -1;
    }
    sprintf(key,"Record\\%s\\0\\gold",tag_uint_to_str(clienttag_str,clienttag));
    return account_set_numattr(account,key,gold);
}


/****************************************************************/


extern int account_check_closed_character(t_account * account, t_clienttag clienttag, char const * realmname, char const * charname)
{
    char const * charlist = account_get_closed_characterlist (account, clienttag, realmname);
    char         tempname[32];

    if (charlist == NULL)
    {
        eventlog(eventlog_level_debug,__FUNCTION__,"no characters in Realm %s",realmname);
    }
    else
    {
        char const * start;
	char const * next_char;
	int    list_len;
	int    name_len;
	int    i;

	eventlog(eventlog_level_debug,__FUNCTION__,"got characterlist \"%s\" for Realm %s",charlist,realmname);

	list_len  = strlen(charlist);
	start     = charlist;
	next_char = start;
	for (i = 0; i < list_len; i++, next_char++)
	{
	    if (',' == *next_char)
	    {
	        name_len = next_char - start;

	        strncpy(tempname, start, name_len);
		tempname[name_len] = '\0';

	        eventlog(eventlog_level_debug,__FUNCTION__,"found character \"%s\"",tempname);

		if (strcmp(tempname, charname) == 0)
		    return 1;

		start = next_char + 1;
	    }
	}

	name_len = next_char - start;

	strncpy(tempname, start, name_len);
	tempname[name_len] = '\0';

	eventlog(eventlog_level_debug,__FUNCTION__,"found tail character \"%s\"",tempname);

	if (strcmp(tempname, charname) == 0)
	    return 1;
    }
    
    return 0;
}


extern char const * account_get_closed_characterlist(t_account * account, t_clienttag clienttag, char const * realmname)
{
    char realmkey[256];
    char clienttag_str[5];
    
    if (!clienttag)
    {
	eventlog(eventlog_level_error,__FUNCTION__,"got bad clienttag");
	return NULL;
    }

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

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

    sprintf(realmkey,"BNET\\CharacterList\\%s\\%s\\0",tag_uint_to_str(clienttag_str,clienttag),realmname);
    eventlog(eventlog_level_debug,__FUNCTION__,"looking for '%s'",realmkey);

    return account_get_strattr(account, realmkey);
}


extern int account_set_closed_characterlist(t_account * account, t_clienttag clienttag, char const * charlist)
{
    char key[256];
    char clienttag_str[5];
    
    if (!clienttag)
    {
	eventlog(eventlog_level_error,__FUNCTION__,"got bad clienttag");
	return -1;
    }

    eventlog(eventlog_level_debug,__FUNCTION__ ,"clienttag='%s', charlist='%s'",tag_uint_to_str(clienttag_str,clienttag),charlist);

    sprintf(key,"BNET\\Characters\\%s\\0",tag_uint_to_str(clienttag_str,clienttag));
    return account_set_strattr(account,key,charlist);
}

extern int account_add_closed_character(t_account * account, t_clienttag clienttag, t_character * ch)
{
    char key[256];
    char clienttag_str[5];
    char hex_buffer[356];
    char chars_in_realm[256];
    char const * old_list;
    
    if (!clienttag)
    {
	eventlog(eventlog_level_error,__FUNCTION__,"got bad clienttag");
	return -1;
    }

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

    eventlog(eventlog_level_debug,__FUNCTION__,"clienttag=\"%s\", realm=\"%s\", name=\"%s\"",tag_uint_to_str(clienttag_str,clienttag),ch->realmname,ch->name);

    sprintf(key,"BNET\\CharacterList\\%s\\%s\\0",tag_uint_to_str(clienttag_str,clienttag),ch->realmname);
    old_list = account_get_strattr(account, key);
    if (old_list)
    {
        sprintf(chars_in_realm, "%s,%s", old_list, ch->name);
    }
    else
    {
        sprintf(chars_in_realm, "%s", ch->name);
    }

    eventlog(eventlog_level_debug,__FUNCTION__,"new character list for realm \"%s\" is \"%s\"", ch->realmname, chars_in_realm);
    account_set_strattr(account, key, chars_in_realm);

    sprintf(key,"BNET\\Characters\\%s\\%s\\%s\\0",tag_uint_to_str(clienttag_str,clienttag),ch->realmname,ch->name);
    str_to_hex(hex_buffer, ch->data, ch->datalen);
    account_set_strattr(account,key,hex_buffer);

    /*
    eventlog(eventlog_level_debug,__FUNCTION__,"key \"%s\"", key);
    eventlog(eventlog_level_debug,__FUNCTION__,"value \"%s\"", hex_buffer);
    */

    return 0;
}

extern int account_set_friend( t_account * account, int friendnum, unsigned int frienduid )
{
	char key[256];
	if ( frienduid == 0 || friendnum < 0 || friendnum >= prefs_get_max_friends())
	{
		return -1;
	}
	sprintf(key, "friend\\%d\\uid", friendnum);

	return account_set_numattr( account, key, frienduid);
}

extern unsigned int account_get_friend( t_account * account, int friendnum)
{
    char key[256];
    int tmp;
    char const * name;
    t_account * acct;

    if (friendnum < 0 || friendnum >= prefs_get_max_friends()) {
	// bogus name (user himself) instead of NULL, otherwise clients might crash
	eventlog(eventlog_level_error, __FUNCTION__, "invalid friendnum %d (max: %d)", friendnum, prefs_get_max_friends());
	return 0;  
    }

    sprintf(key, "friend\\%d\\uid", friendnum);
    tmp = account_get_numattr(account, key);
    if(!tmp) {
        // ok, looks like we have a problem. Maybe friends still stored in old format?

        sprintf(key,"friend\\%d\\name",friendnum);
        name = account_get_strattr(account,key);

        if (name) 
        {
    	    if ((acct = accountlist_find_account(name)) != NULL)
            {
        	tmp = account_get_uid(acct);
                account_set_friend(account,friendnum,tmp);
                account_set_strattr(account,key,NULL); //remove old username-based friend now                  

                return tmp;
	    }
            account_set_strattr(account,key,NULL); //remove old username-based friend now                  
	    eventlog(eventlog_level_warn, __FUNCTION__, "unexistant friend name ('%s') in old storage format", name);
	    return 0;
        }

	eventlog(eventlog_level_error, __FUNCTION__, "could not find friend (friendno: %d of '%s')", friendnum, account_get_name(account));
	return 0;
    }

    return tmp;
}

static int account_set_friendcount( t_account * account, int count)
{
	if (count < 0 || count > prefs_get_max_friends())
	{
		return -1;
	}

	return account_set_numattr( account, "friend\\count", count);
}

extern int account_get_friendcount( t_account * account )
{
    return account_get_numattr( account, "friend\\count" );
}

extern int account_add_friend( t_account * my_acc, t_account * facc)
{
    unsigned my_uid;
    unsigned fuid;
    int nf;
    t_list *flist;

    if (my_acc == NULL || facc == NULL) {
	eventlog(eventlog_level_error, __FUNCTION__, "got NULL account");
	return -1;
    }

    my_uid = account_get_uid(my_acc);
    fuid = account_get_uid(facc);

    if (my_acc == facc) return -2;

    nf = account_get_friendcount(my_acc);
    if (nf >= prefs_get_max_friends()) return -3;

    flist = account_get_friends(my_acc);
    if (flist == NULL) return -1;
    if (friendlist_find_account(flist, facc) != NULL) return -4;

    account_set_friend(my_acc, nf, fuid);
    account_set_friendcount(my_acc, nf + 1);
    if (account_check_mutual(facc, my_uid) == 0)
	friendlist_add_account(flist, facc, 1);
    else
	friendlist_add_account(flist, facc, 0);

    return 0;
}

extern int account_remove_friend( t_account * account, int friendnum )
{
    unsigned i;
    int n = account_get_friendcount(account);

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

    if (friendnum < 0 || friendnum >= n) {
	eventlog(eventlog_level_error, __FUNCTION__, "got invalid friendnum (friendnum: %d max: %d)", friendnum, n);
	return -1;
    }

    for(i = friendnum ; i < n - 1; i++)
	account_set_friend(account, i, account_get_friend(account, i + 1));

    account_set_friend(account, n-1, 0); /* FIXME: should delete the attribute */
    account_set_friendcount(account, n-1);

    return 0;
}

extern int account_remove_friend2( t_account * account, const char * friend)
{
    t_list *flist;
    t_friend *fr;
    unsigned i, uid;
    int n;

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

    if (friend == NULL) {
	eventlog(eventlog_level_error, __FUNCTION__, "got NULL friend username");
	return -1;
    }

    if ((flist = account_get_friends(account)) == NULL)
	return -1;

    if ((fr = friendlist_find_username(flist, friend)) == NULL) return -2;

    n = account_get_friendcount(account);
    uid = account_get_uid(friend_get_account(fr));
    for (i = 0; i < n; i++)
	if (account_get_friend(account, i) == uid) {
    	    t_list * fflist;
    	    t_friend * ffr;
    	    t_account * facc;

	    account_remove_friend(account, i);
    	    if((facc = friend_get_account(fr)) && 
	       (fflist = account_get_friends(facc)) && 
	       (ffr = friendlist_find_account(fflist, account)))
        	    friend_set_mutual(ffr, 0);
	    friendlist_remove_friend(flist, fr);
	    return i;
	}

    return -2;
}

// Some Extra Commands for REAL admins to promote other users to Admins
// And Moderators of channels
extern int account_set_admin( t_account * account )
{
	return account_set_strattr( account, "BNET\\auth\\admin", "true");
}
extern int account_set_demoteadmin( t_account * account )
{
	return account_set_strattr( account, "BNET\\auth\\admin", "false" );
}

extern unsigned int account_get_command_groups(t_account * account)
{
    return account_get_numattr(account,"BNET\\auth\\command_groups");
}
extern int account_set_command_groups(t_account * account, unsigned int groups)
{
    return account_set_numattr(account,"BNET\\auth\\command_groups",groups);
}

// WAR3 Play Game & Profile Funcs

extern char const * race_get_str(unsigned int race)
{
	switch(race) {
	case W3_RACE_ORCS:
	    return "orcs";
	case W3_RACE_HUMANS:
	    return "humans";
	case W3_RACE_UNDEAD:
	    return "undead";
	case W3_RACE_NIGHTELVES:
	    return "nightelves";
	case W3_RACE_RANDOM:
	    return "random";
	case W3_ICON_UNDEAD:
		return "undead";
	case W3_ICON_RANDOM:
		return "random";
	case W3_ICON_DEMONS:
		return "demons";
	default:
	    eventlog(eventlog_level_warn,__FUNCTION__,"unknown race: %x", race);
	    return NULL;
	}
}

extern int account_inc_racewins( t_account * account, unsigned int intrace, t_clienttag clienttag)
{
	char table[256];
	char clienttag_str[5];
	unsigned int wins;
	char const * race = race_get_str(intrace);

	if(!race)
	    return -1;

	sprintf(table,"Record\\%s\\%s\\wins",tag_uint_to_str(clienttag_str,clienttag), race);
	wins = account_get_numattr(account,table);
	wins++;
		
	return account_set_numattr(account,table,wins);
}

extern int account_get_racewins( t_account * account, unsigned int intrace, t_clienttag clienttag)
{	
	char table[256];
	char clienttag_str[5];
	char const *race = race_get_str(intrace);

	if(!race)
	    return 0;
	
	sprintf(table,"Record\\%s\\%s\\wins",tag_uint_to_str(clienttag_str,clienttag), race);
	return account_get_numattr(account,table);
}

extern int account_inc_racelosses( t_account * account, unsigned int intrace, t_clienttag clienttag)
{
	char table[256];
	char clienttag_str[5];
	unsigned int losses;
	char const *race = race_get_str(intrace);

	if(!race)
	    return -1;

	sprintf(table,"Record\\%s\\%s\\losses",tag_uint_to_str(clienttag_str,clienttag),race);

	losses=account_get_numattr(account,table);
	
	losses++;
	
	return account_set_numattr(account,table,losses);
	
}

extern int account_get_racelosses( t_account * account, unsigned int intrace, t_clienttag clienttag)
{	
	char table[256];
	char clienttag_str[5];