src/game/AccountMgr.cpp

   1 /*
   2  * Copyright (C) 2005-2013 MaNGOS <http://getmangos.com/>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 #include "AccountMgr.h"
  20 #include "Database/DatabaseEnv.h"
  21 #include "ObjectAccessor.h"
  22 #include "ObjectGuid.h"
  23 #include "Player.h"
  24 #include "Policies/SingletonImp.h"
  25 #include "Util.h"
  26 #include "Auth/Sha1.h"
  27
  28 extern DatabaseType LoginDatabase;
  29
  30 INSTANTIATE_SINGLETON_1(AccountMgr);
  31
  32 AccountMgr::AccountMgr()
  33 {}
  34
  35 AccountMgr::~AccountMgr()
  36 {}
  37
  38 AccountOpResult AccountMgr::CreateAccount(std::string username, std::string password)
  39 {
  40     if (utf8length(username) > MAX_ACCOUNT_STR)
  41         return AOR_NAME_TOO_LONG;                           // username's too long
  42
  43     normalizeString(username);
  44     normalizeString(password);
  45
  46     if (GetId(username))
  47     {
  48         return AOR_NAME_ALREDY_EXIST;                       // username does already exist
  49     }
  50
  51     if (!LoginDatabase.PExecute("INSERT INTO account(username,sha_pass_hash,joindate) VALUES('%s','%s',NOW())", username.c_str(), CalculateShaPassHash(username, password).c_str()))
  52         return AOR_DB_INTERNAL_ERROR;                       // unexpected error
  53     LoginDatabase.Execute("INSERT INTO realmcharacters (realmid, acctid, numchars) SELECT realmlist.id, account.id, 0 FROM realmlist,account LEFT JOIN realmcharacters ON acctid=account.id WHERE acctid IS NULL");
  54
  55     return AOR_OK;                                          // everything's fine
  56 }
  57
  58 AccountOpResult AccountMgr::DeleteAccount(uint32 accid)
  59 {
  60     QueryResult* result = LoginDatabase.PQuery("SELECT 1 FROM account WHERE id='%u'", accid);
  61     if (!result)
  62         return AOR_NAME_NOT_EXIST;                          // account doesn't exist
  63     delete result;
  64
  65     // existing characters list
  66     result = CharacterDatabase.PQuery("SELECT guid FROM characters WHERE account='%u'", accid);
  67     if (result)
  68     {
  69         do
  70         {
  71             Field* fields = result->Fetch();
  72             uint32 guidlo = fields[0].GetUInt32();
  73             ObjectGuid guid = ObjectGuid(HIGHGUID_PLAYER, guidlo);
  74
  75             // kick if player currently
  76             ObjectAccessor::KickPlayer(guid);
  77             Player::DeleteFromDB(guid, accid, false);       // no need to update realm characters
  78         }
  79         while (result->NextRow());
  80
  81         delete result;
  82     }
  83
  84     // table realm specific but common for all characters of account for realm
  85     CharacterDatabase.PExecute("DELETE FROM character_tutorial WHERE account = '%u'", accid);
  86
  87     LoginDatabase.BeginTransaction();
  88
  89     bool res =
  90         LoginDatabase.PExecute("DELETE FROM account WHERE id='%u'", accid) &&
  91         LoginDatabase.PExecute("DELETE FROM account_access WHERE id ='%d'", accid) &&
  92         LoginDatabase.PExecute("DELETE FROM realmcharacters WHERE acctid='%u'", accid);
  93
  94     LoginDatabase.CommitTransaction();
  95
  96     if (!res)
  97         return AOR_DB_INTERNAL_ERROR;                       // unexpected error;
  98
  99     return AOR_OK;
 100 }
 101
 102 AccountOpResult AccountMgr::ChangeUsername(uint32 accid, std::string new_uname, std::string new_passwd)
 103 {
 104     QueryResult* result = LoginDatabase.PQuery("SELECT 1 FROM account WHERE id='%u'", accid);
 105     if (!result)
 106         return AOR_NAME_NOT_EXIST;                          // account doesn't exist
 107     delete result;
 108
 109     if (utf8length(new_uname) > MAX_ACCOUNT_STR)
 110         return AOR_NAME_TOO_LONG;
 111
 112     if (utf8length(new_passwd) > MAX_ACCOUNT_STR)
 113         return AOR_PASS_TOO_LONG;
 114
 115     normalizeString(new_uname);
 116     normalizeString(new_passwd);
 117
 118     std::string safe_new_uname = new_uname;
 119     LoginDatabase.escape_string(safe_new_uname);
 120
 121     if (!LoginDatabase.PExecute("UPDATE account SET v='0',s='0',username='%s',sha_pass_hash='%s' WHERE id='%u'", safe_new_uname.c_str(),
 122                                 CalculateShaPassHash(new_uname, new_passwd).c_str(), accid))
 123         return AOR_DB_INTERNAL_ERROR;                       // unexpected error
 124
 125     return AOR_OK;
 126 }
 127
 128 AccountOpResult AccountMgr::ChangePassword(uint32 accid, std::string new_passwd)
 129 {
 130     std::string username;
 131
 132     if (!GetName(accid, username))
 133         return AOR_NAME_NOT_EXIST;                          // account doesn't exist
 134
 135     if (utf8length(new_passwd) > MAX_ACCOUNT_STR)
 136         return AOR_PASS_TOO_LONG;
 137
 138     normalizeString(new_passwd);
 139
 140     // also reset s and v to force update at next realmd login
 141     if (!LoginDatabase.PExecute("UPDATE account SET v='0', s='0', sha_pass_hash='%s' WHERE id='%u'",
 142                                 CalculateShaPassHash(username, new_passwd).c_str(), accid))
 143         return AOR_DB_INTERNAL_ERROR;                       // unexpected error
 144
 145     return AOR_OK;
 146 }
 147
 148 uint32 AccountMgr::GetId(std::string username)
 149 {
 150     LoginDatabase.escape_string(username);
 151     QueryResult* result = LoginDatabase.PQuery("SELECT id FROM account WHERE username = '%s'", username.c_str());
 152     if (!result)
 153         return 0;
 154     else
 155     {
 156         uint32 id = (*result)[0].GetUInt32();
 157         delete result;
 158         return id;
 159     }
 160 }
 161
 162 AccountTypes AccountMgr::GetSecurity(uint32 acc_id)
 163 {
 164     QueryResult* result = LoginDatabase.PQuery("SELECT gmlevel FROM account_access WHERE id = '%u'", acc_id);
 165     if (result)
 166     {
 167         AccountTypes sec = AccountTypes((*result)[0].GetInt32());
 168         delete result;
 169         return sec;
 170     }
 171
 172     return SEC_PLAYER;
 173 }
 174
 175 bool AccountMgr::GetName(uint32 acc_id, std::string& name)
 176 {
 177     QueryResult* result = LoginDatabase.PQuery("SELECT username FROM account WHERE id = '%u'", acc_id);
 178     if (result)
 179     {
 180         name = (*result)[0].GetCppString();
 181         delete result;
 182         return true;
 183     }
 184
 185     return false;
 186 }
 187
 188 uint32 AccountMgr::GetCharactersCount(uint32 acc_id)
 189 {
 190     // check character count
 191     QueryResult* result = CharacterDatabase.PQuery("SELECT COUNT(guid) FROM characters WHERE account = '%u'", acc_id);
 192     if (result)
 193     {
 194         Field* fields = result->Fetch();
 195         uint32 charcount = fields[0].GetUInt32();
 196         delete result;
 197         return charcount;
 198     }
 199     else
 200         return 0;
 201 }
 202
 203 bool AccountMgr::CheckPassword(uint32 accid, std::string passwd)
 204 {
 205     std::string username;
 206     if (!GetName(accid, username))
 207         return false;
 208
 209     normalizeString(passwd);
 210
 211     QueryResult* result = LoginDatabase.PQuery("SELECT 1 FROM account WHERE id='%u' AND sha_pass_hash='%s'", accid, CalculateShaPassHash(username, passwd).c_str());
 212     if (result)
 213     {
 214         delete result;
 215         return true;
 216     }
 217
 218     return false;
 219 }
 220
 221 bool AccountMgr::normalizeString(std::string& utf8str)
 222 {
 223     wchar_t wstr_buf[MAX_ACCOUNT_STR + 1];
 224
 225     size_t wstr_len = MAX_ACCOUNT_STR;
 226     if (!Utf8toWStr(utf8str, wstr_buf, wstr_len))
 227         return false;
 228
 229     std::transform(&wstr_buf[0], wstr_buf + wstr_len, &wstr_buf[0], wcharToUpperOnlyLatin);
 230
 231     return WStrToUtf8(wstr_buf, wstr_len, utf8str);
 232 }
 233
 234 std::string AccountMgr::CalculateShaPassHash(std::string& name, std::string& password)
 235 {
 236     Sha1Hash sha;
 237     sha.Initialize();
 238     sha.UpdateData(name);
 239     sha.UpdateData(":");
 240     sha.UpdateData(password);
 241     sha.Finalize();
 242
 243     std::string encoded;
 244     hexEncodeByteArray(sha.GetDigest(), sha.GetLength(), encoded);
 245
 246     return encoded;
 247 }