src/game/PlayerDump.cpp

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