root/trunk/src/game/PlayerDump.cpp @ 279

Revision 279, 20.7 kB (checked in by yumileroy, 17 years ago)

Merged commit 269 (5f0e38da128a).

Original author: gvcoman
Date: 2008-11-21 14:34:05-05:00
RevLine 
[263]1/*
2 * Copyright (C) 2005-2008 MaNGOS <http://www.mangosproject.org/>
3 *
4 * Copyright (C) 2008 Trinity <http://www.trinitycore.org/>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
[279]13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
[263]14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
[279]18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
[263]19 */
20
21#include "Common.h"
22#include "PlayerDump.h"
23#include "Database/DatabaseEnv.h"
24#include "Database/SQLStorage.h"
25#include "UpdateFields.h"
26#include "ObjectMgr.h"
27
28// Character Dump tables
29#define DUMP_TABLE_COUNT 19
30
31struct DumpTable
32{
33    char const* name;
34    DumpTableType type;
35};
36
37static DumpTable dumpTables[DUMP_TABLE_COUNT] =
38{
39    { "characters",               DTT_CHARACTER  },
40    { "character_queststatus",    DTT_CHAR_TABLE },
41    { "character_reputation",     DTT_CHAR_TABLE },
42    { "character_spell",          DTT_CHAR_TABLE },
43    { "character_spell_cooldown", DTT_CHAR_TABLE },
44    { "character_action",         DTT_CHAR_TABLE },
45    { "character_aura",           DTT_CHAR_TABLE },
46    { "character_homebind",       DTT_CHAR_TABLE },
47    { "character_ticket",         DTT_CHAR_TABLE },
48    { "character_inventory",      DTT_INVENTORY  },
49    { "mail",                     DTT_MAIL       },
50    { "mail_items",               DTT_MAIL_ITEM  },
51    { "item_instance",            DTT_ITEM       },
52    { "character_gifts",          DTT_ITEM_GIFT  },
53    { "item_text",                DTT_ITEM_TEXT  },
54    { "character_pet",            DTT_PET        },
55    { "pet_aura",                 DTT_PET_TABLE  },
56    { "pet_spell",                DTT_PET_TABLE  },
57    { "pet_spell_cooldown",       DTT_PET_TABLE  },
58};
59
60// Low level functions
61static bool findtoknth(std::string &str, int n, std::string::size_type &s, std::string::size_type &e)
62{
63    int i; s = e = 0;
64    std::string::size_type size = str.size();
65    for(i = 1; s < size && i < n; s++) if(str[s] == ' ') ++i;
66    if (i < n)
67        return false;
68
69    e = str.find(' ', s);
70
71    return e != std::string::npos;
72}
73
74std::string gettoknth(std::string &str, int n)
75{
76    std::string::size_type s = 0, e = 0;
77    if(!findtoknth(str, n, s, e))
78        return "";
79
80    return str.substr(s, e-s);
81}
82
83bool findnth(std::string &str, int n, std::string::size_type &s, std::string::size_type &e)
84{
85    s = str.find("VALUES ('")+9;
86    if (s == std::string::npos) return false;
87
88    do
89    {
90        e = str.find("'",s);
91        if (e == std::string::npos) return false;
92    } while(str[e-1] == '\\');
93
94    for(int i = 1; i < n; i++)
95    {
96        do
97        {
98            s = e+4;
99            e = str.find("'",s);
100            if (e == std::string::npos) return false;
101        } while (str[e-1] == '\\');
102    }
103    return true;
104}
105
106std::string gettablename(std::string &str)
107{
108    std::string::size_type s = 13;
109    std::string::size_type e = str.find(_TABLE_SIM_, s);
110    if (e == std::string::npos)
111        return "";
112
113    return str.substr(s, e-s);
114}
115
116bool changenth(std::string &str, int n, const char *with, bool insert = false, bool nonzero = false)
117{
118    std::string::size_type s, e;
119    if(!findnth(str,n,s,e))
120        return false;
121
122    if(nonzero && str.substr(s,e-s) == "0")
123        return true;                                        // not an error
124    if(!insert)
125        str.replace(s,e-s, with);
126    else
127        str.insert(s, with);
128
129    return true;
130}
131
132std::string getnth(std::string &str, int n)
133{
134    std::string::size_type s, e;
135    if(!findnth(str,n,s,e))
136        return "";
137
138    return str.substr(s, e-s);
139}
140
141bool changetoknth(std::string &str, int n, const char *with, bool insert = false, bool nonzero = false)
142{
143    std::string::size_type s = 0, e = 0;
144    if(!findtoknth(str, n, s, e))
145        return false;
146    if(nonzero && str.substr(s,e-s) == "0")
147        return true;                                        // not an error
148    if(!insert)
149        str.replace(s, e-s, with);
150    else
151        str.insert(s, with);
152
153    return true;
154}
155
156uint32 registerNewGuid(uint32 oldGuid, std::map<uint32, uint32> &guidMap, uint32 hiGuid)
157{
158    std::map<uint32, uint32>::iterator itr = guidMap.find(oldGuid);
159    if(itr != guidMap.end())
160        return itr->second;
161
162    uint32 newguid = hiGuid + guidMap.size();
163    guidMap[oldGuid] = newguid;
164    return newguid;
165}
166
167bool changeGuid(std::string &str, int n, std::map<uint32, uint32> &guidMap, uint32 hiGuid, bool nonzero = false)
168{
169    char chritem[20];
170    uint32 oldGuid = atoi(getnth(str, n).c_str());
171    if (nonzero && oldGuid == 0)
172        return true;                                        // not an error
173
174    uint32 newGuid = registerNewGuid(oldGuid, guidMap, hiGuid);
175    snprintf(chritem, 20, "%d", newGuid);
176
177    return changenth(str, n, chritem, false, nonzero);
178}
179
180bool changetokGuid(std::string &str, int n, std::map<uint32, uint32> &guidMap, uint32 hiGuid, bool nonzero = false)
181{
182    char chritem[20];
183    uint32 oldGuid = atoi(gettoknth(str, n).c_str());
184    if (nonzero && oldGuid == 0)
185        return true;                                        // not an error
186
187    uint32 newGuid = registerNewGuid(oldGuid, guidMap, hiGuid);
188    snprintf(chritem, 20, "%d", newGuid);
189
190    return changetoknth(str, n, chritem, false, nonzero);
191}
192
193std::string CreateDumpString(char const* tableName, QueryResult *result)
194{
195    if(!tableName || !result) return "";
196    std::ostringstream ss;
197    ss << "INSERT INTO "<< _TABLE_SIM_ << tableName << _TABLE_SIM_ << " VALUES (";
198    Field *fields = result->Fetch();
199    for(uint32 i = 0; i < result->GetFieldCount(); i++)
200    {
201        if (i == 0) ss << "'";
202        else ss << ", '";
203
204        std::string s = fields[i].GetCppString();
205        CharacterDatabase.escape_string(s);
206        ss << s;
207
208        ss << "'";
209    }
210    ss << ");";
211    return ss.str();
212}
213
214std::string PlayerDumpWriter::GenerateWhereStr(char const* field, uint32 guid)
215{
216    std::ostringstream wherestr;
217    wherestr << field << " = '" << guid << "'";
218    return wherestr.str();
219}
220
221std::string PlayerDumpWriter::GenerateWhereStr(char const* field, GUIDs const& guids, GUIDs::const_iterator& itr)
222{
223    std::ostringstream wherestr;
224    wherestr << field << " IN ('";
225    for(; itr != guids.end(); ++itr)
226    {
227        wherestr << *itr;
228
229        if(wherestr.str().size() > MAX_QUERY_LEN - 50)      // near to max query
230        {
231            ++itr;
232            break;
233        }
234
235        GUIDs::const_iterator itr2 = itr;
236        if(++itr2 != guids.end())
237            wherestr << "','";
238    }
239    wherestr << "')";
240    return wherestr.str();
241}
242
243void StoreGUID(QueryResult *result,uint32 field,std::set<uint32>& guids)
244{
245    Field* fields = result->Fetch();
246    uint32 guid = fields[field].GetUInt32();
247    if(guid)
248        guids.insert(guid);
249}
250
251void StoreGUID(QueryResult *result,uint32 data,uint32 field, std::set<uint32>& guids)
252{
253    Field* fields = result->Fetch();
254    std::string dataStr = fields[data].GetCppString();
255    uint32 guid = atoi(gettoknth(dataStr, field).c_str());
256    if(guid)
257        guids.insert(guid);
258}
259
260// Writing - High-level functions
261void PlayerDumpWriter::DumpTable(std::string& dump, uint32 guid, char const*tableFrom, char const*tableTo, DumpTableType type)
262{
263    GUIDs const* guids = NULL;
264    char const* fieldname = NULL;
265
266    switch ( type )
267    {
268        case DTT_ITEM:      fieldname = "guid";      guids = &items; break;
269        case DTT_ITEM_GIFT: fieldname = "item_guid"; guids = &items; break;
270        case DTT_PET:       fieldname = "owner";                     break;
271        case DTT_PET_TABLE: fieldname = "guid";      guids = &pets;  break;
272        case DTT_MAIL:      fieldname = "receiver";                  break;
273        case DTT_MAIL_ITEM: fieldname = "mail_id";   guids = &mails; break;
274        case DTT_ITEM_TEXT: fieldname = "id";        guids = &texts; break;
275        default:            fieldname = "guid";                      break;
276    }
277
278    // for guid set stop if set is empty
279    if(guids && guids->empty())
[279]280        return;                                             // nothing to do
[263]281
282    // setup for guids case start position
283    GUIDs::const_iterator guids_itr;
284    if(guids)
285        guids_itr = guids->begin();
286
287    do
288    {
289        std::string wherestr;
290
291        if(guids)                                           // set case, get next guids string
292            wherestr = GenerateWhereStr(fieldname,*guids,guids_itr);
293        else                                                // not set case, get single guid string
294            wherestr = GenerateWhereStr(fieldname,guid);
295
296        QueryResult *result = CharacterDatabase.PQuery("SELECT * FROM %s WHERE %s", tableFrom, wherestr.c_str());
297        if(!result)
298            return;
299
300        do
301        {
302            // collect guids
303            switch ( type )
304            {
305            case DTT_INVENTORY:
306                StoreGUID(result,3,items); break;           // item guid collection
307            case DTT_ITEM:
308                StoreGUID(result,0,ITEM_FIELD_ITEM_TEXT_ID,texts); break;
309                // item text id collection
310            case DTT_PET:
311                StoreGUID(result,0,pets);  break;           // pet guid collection
312            case DTT_MAIL:
313                StoreGUID(result,0,mails);                  // mail id collection
314                StoreGUID(result,6,texts); break;           // item text id collection
315            case DTT_MAIL_ITEM:
316                StoreGUID(result,1,items); break;           // item guid collection
317            default:                       break;
318            }
319
320            dump += CreateDumpString(tableTo, result);
321            dump += "\n";
322        }
323        while (result->NextRow());
324
325        delete result;
326    }
327    while(guids && guids_itr != guids->end());              // not set case iterate single time, set case iterate for all guids
328}
329
330std::string PlayerDumpWriter::GetDump(uint32 guid)
331{
332    std::string dump;
333    for(int i = 0; i < DUMP_TABLE_COUNT; i++)
334        DumpTable(dump, guid, dumpTables[i].name, dumpTables[i].name, dumpTables[i].type);
335
336    // TODO: Add instance/group..
337    // TODO: Add a dump level option to skip some non-important tables
338
339    return dump;
340}
341
342DumpReturn PlayerDumpWriter::WriteDump(std::string file, uint32 guid)
343{
344    FILE *fout = fopen(file.c_str(), "w");
345    if (!fout)
[279]346        return DUMP_FILE_OPEN_ERROR;
[263]347
348    std::string dump = GetDump(guid);
349
350    fprintf(fout,"%s\n",dump.c_str());
351    fclose(fout);
352    return DUMP_SUCCESS;
353}
354
355// Reading - High-level functions
356#define ROLLBACK(DR) {CharacterDatabase.RollbackTransaction(); fclose(fin); return (DR);}
357
358DumpReturn PlayerDumpReader::LoadDump(std::string file, uint32 account, std::string name, uint32 guid)
359{
360    // check character count
361    {
362        QueryResult *result = CharacterDatabase.PQuery("SELECT COUNT(guid) FROM characters WHERE account = '%d'", account);
363        uint8 charcount = 0;
364        if ( result )
365        {
366            Field *fields=result->Fetch();
367            charcount = fields[0].GetUInt8();
368            delete result;
369
370            if (charcount >= 10)
371                return DUMP_TOO_MANY_CHARS;
372        }
373    }
[279]374
[263]375    FILE *fin = fopen(file.c_str(), "r");
376    if(!fin)
[279]377        return DUMP_FILE_OPEN_ERROR;
[263]378
379    QueryResult * result = NULL;
380    char newguid[20], chraccount[20], newpetid[20], currpetid[20], lastpetid[20];
381
382    // make sure the same guid doesn't already exist and is safe to use
383    bool incHighest = true;
384    if(guid != 0 && guid < objmgr.m_hiCharGuid)
385    {
386        result = CharacterDatabase.PQuery("SELECT * FROM characters WHERE guid = '%d'", guid);
387        if (result)
388        {
389            guid = objmgr.m_hiCharGuid;                     // use first free if exists
390            delete result;
391        }
392        else incHighest = false;
393    }
[279]394    else
395        guid = objmgr.m_hiCharGuid;
[263]396
397    // normalize the name if specified and check if it exists
398    if(!normalizePlayerName(name))
399        name = "";
400
401    if(ObjectMgr::IsValidName(name,true))
402    {
403        CharacterDatabase.escape_string(name);              // for safe, we use name only for sql quearies anyway
404        result = CharacterDatabase.PQuery("SELECT * FROM characters WHERE name = '%s'", name.c_str());
405        if (result)
406        {
407            name = "";                                      // use the one from the dump
408            delete result;
409        }
410    }
411    else name = "";
412
413    // name encoded or empty
414
415    snprintf(newguid, 20, "%d", guid);
416    snprintf(chraccount, 20, "%d", account);
417    snprintf(newpetid, 20, "%d", objmgr.GeneratePetNumber());
418    snprintf(lastpetid, 20, "%s", "");
419
420    std::map<uint32,uint32> items;
421    std::map<uint32,uint32> mails;
422    char buf[32000] = "";
423
424    typedef std::map<uint32, uint32> PetIds;                // old->new petid relation
425    typedef PetIds::value_type PetIdsPair;
426    PetIds petids;
427
428    CharacterDatabase.BeginTransaction();
429    while(!feof(fin))
430    {
431        if(!fgets(buf, 32000, fin))
432        {
433            if(feof(fin)) break;
434            ROLLBACK(DUMP_FILE_BROKEN);
435        }
436
437        std::string line; line.assign(buf);
438
439        // skip empty strings
440        if(line.find_first_not_of(" \t\n\r\7")==std::string::npos)
441            continue;
442
443        // determine table name and load type
444        std::string tn = gettablename(line);
445        if(tn.empty())
446        {
447            sLog.outError("LoadPlayerDump: Can't extract table name from line: '%s'!", line.c_str());
448            ROLLBACK(DUMP_FILE_BROKEN);
449        }
450
451        DumpTableType type;
452        uint8 i;
453        for(i = 0; i < DUMP_TABLE_COUNT; i++)
454        {
455            if (tn == dumpTables[i].name)
456            {
457                type = dumpTables[i].type;
458                break;
459            }
460        }
461
462        if (i == DUMP_TABLE_COUNT)
463        {
464            sLog.outError("LoadPlayerDump: Unknown table: '%s'!", tn.c_str());
465            ROLLBACK(DUMP_FILE_BROKEN);
466        }
467
468        // change the data to server values
469        switch(type)
470        {
471            case DTT_CHAR_TABLE:
472                if(!changenth(line, 1, newguid))
[279]473                    ROLLBACK(DUMP_FILE_BROKEN);
[263]474                break;
475
476            case DTT_CHARACTER:                             // character t.
477            {
478                if(!changenth(line, 1, newguid))
[279]479                    ROLLBACK(DUMP_FILE_BROKEN);
[263]480
481                // guid, data field:guid, items
482                if(!changenth(line, 2, chraccount))
[279]483                    ROLLBACK(DUMP_FILE_BROKEN);
[263]484                std::string vals = getnth(line, 3);
485                if(!changetoknth(vals, OBJECT_FIELD_GUID+1, newguid))
[279]486                    ROLLBACK(DUMP_FILE_BROKEN);
[263]487                for(uint16 field = PLAYER_FIELD_INV_SLOT_HEAD; field < PLAYER_FARSIGHT; field++)
488                    if(!changetokGuid(vals, field+1, items, objmgr.m_hiItemGuid, true))
[279]489                        ROLLBACK(DUMP_FILE_BROKEN);
[263]490                if(!changenth(line, 3, vals.c_str()))
[279]491                    ROLLBACK(DUMP_FILE_BROKEN);
[263]492                if (name == "")
493                {
494                    // check if the original name already exists
495                    name = getnth(line, 4);
496                    CharacterDatabase.escape_string(name);
497
498                    result = CharacterDatabase.PQuery("SELECT * FROM characters WHERE name = '%s'", name.c_str());
499                    if (result)
500                    {
501                        delete result;
502                                                            // rename on login: `at_login` field 30 in raw field list
503                        if(!changenth(line, 30, "1"))
[279]504                            ROLLBACK(DUMP_FILE_BROKEN);
[263]505                    }
506                }
507                else if(!changenth(line, 4, name.c_str()))
[279]508                    ROLLBACK(DUMP_FILE_BROKEN);
[263]509
510                break;
511            }
512            case DTT_INVENTORY:                             // character_inventory t.
513            {
514                if(!changenth(line, 1, newguid))
[279]515                    ROLLBACK(DUMP_FILE_BROKEN);
[263]516
517                // bag, item
518                if(!changeGuid(line, 2, items, objmgr.m_hiItemGuid, true))
[279]519                    ROLLBACK(DUMP_FILE_BROKEN);
520                if(!changeGuid(line, 4, items, objmgr.m_hiItemGuid))
521                    ROLLBACK(DUMP_FILE_BROKEN);
[263]522                break;
523            }
524            case DTT_ITEM:                                  // item_instance t.
525            {
526                // item, owner, data field:item, owner guid
527                if(!changeGuid(line, 1, items, objmgr.m_hiItemGuid))
[279]528                    ROLLBACK(DUMP_FILE_BROKEN);
529                if(!changenth(line, 2, newguid))
530                    ROLLBACK(DUMP_FILE_BROKEN);
[263]531                std::string vals = getnth(line,3);
532                if(!changetokGuid(vals, OBJECT_FIELD_GUID+1, items, objmgr.m_hiItemGuid))
[279]533                    ROLLBACK(DUMP_FILE_BROKEN);
534                if(!changetoknth(vals, ITEM_FIELD_OWNER+1, newguid))
535                    ROLLBACK(DUMP_FILE_BROKEN);
536                if(!changenth(line, 3, vals.c_str()))
537                    ROLLBACK(DUMP_FILE_BROKEN);
[263]538                break;
539            }
540            case DTT_ITEM_GIFT:                             // character_gift
541            {
542                // guid,item_guid,
543                if(!changenth(line, 1, newguid))
[279]544                    ROLLBACK(DUMP_FILE_BROKEN);
545                if(!changeGuid(line, 2, items, objmgr.m_hiItemGuid))
546                    ROLLBACK(DUMP_FILE_BROKEN);
[263]547                break;
548            }
549            case DTT_PET:                                   // character_pet t
550            {
551                //store a map of old pet id to new inserted pet id for use by type 5 tables
552                snprintf(currpetid, 20, "%s", getnth(line, 1).c_str());
553                if(strlen(lastpetid)==0) snprintf(lastpetid, 20, "%s", currpetid);
554                if(strcmp(lastpetid,currpetid)!=0)
555                {
556                    snprintf(newpetid, 20, "%d", objmgr.GeneratePetNumber());
557                    snprintf(lastpetid, 20, "%s", currpetid);
558                }
559
560                std::map<uint32, uint32> :: const_iterator petids_iter = petids.find(atoi(currpetid));
561
562                if(petids_iter == petids.end())
563                {
564                    petids.insert(PetIdsPair(atoi(currpetid), atoi(newpetid)));
565                }
566
567                // item, entry, owner, ...
568                if(!changenth(line, 1, newpetid))
[279]569                    ROLLBACK(DUMP_FILE_BROKEN);
570                if(!changenth(line, 3, newguid))
571                    ROLLBACK(DUMP_FILE_BROKEN);
[263]572
573                break;
574            }
575            case DTT_PET_TABLE:                             // pet_aura, pet_spell, pet_spell_cooldown t
576            {
577                snprintf(currpetid, 20, "%s", getnth(line, 1).c_str());
578
579                // lookup currpetid and match to new inserted pet id
580                std::map<uint32, uint32> :: const_iterator petids_iter = petids.find(atoi(currpetid));
581                if(petids_iter == petids.end())             // couldn't find new inserted id
[279]582                    ROLLBACK(DUMP_FILE_BROKEN);
[263]583
584                snprintf(newpetid, 20, "%d", petids_iter->second);
585
586                if(!changenth(line, 1, newpetid))
[279]587                    ROLLBACK(DUMP_FILE_BROKEN);
[263]588
589                break;
590            }
591            case DTT_MAIL:                                  // mail
592            {
593                // id,messageType,stationery,sender,receiver
594                if(!changeGuid(line, 1, mails, objmgr.m_mailid))
[279]595                    ROLLBACK(DUMP_FILE_BROKEN);
596                if(!changenth(line, 5, newguid))
597                    ROLLBACK(DUMP_FILE_BROKEN);
[263]598                break;
599            }
600            case DTT_MAIL_ITEM:                             // mail_items
601            {
602                // mail_id,item_guid,item_template,receiver
603                if(!changeGuid(line, 1, mails, objmgr.m_mailid))
[279]604                    ROLLBACK(DUMP_FILE_BROKEN);
605                if(!changeGuid(line, 2, items, objmgr.m_hiItemGuid))
606                    ROLLBACK(DUMP_FILE_BROKEN);
607                if(!changenth(line, 4, newguid))
608                    ROLLBACK(DUMP_FILE_BROKEN);
[263]609                break;
610            }
611            default:
612                sLog.outError("Unknown dump table type: %u",type);
613                break;
614        }
615
616        if(!CharacterDatabase.Execute(line.c_str()))
[279]617            ROLLBACK(DUMP_FILE_BROKEN);
[263]618    }
619
620    CharacterDatabase.CommitTransaction();
621
622    objmgr.m_hiItemGuid += items.size();
623    objmgr.m_mailid     += mails.size();
624
625    if(incHighest)
626        ++objmgr.m_hiCharGuid;
627
628    fclose(fin);
629
630    return DUMP_SUCCESS;
631}
Note: See TracBrowser for help on using the browser.