开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
RealmListSrv.cpp
资源名称：wow.rar　[点击查看]
上传用户：jxpjxmjjw
上传日期：2009-12-07
资源大小：5877k
文件大小：16k
源码类别：

模拟服务器

开发平台：

Visual C++

RealmListSrv.cpp：源码内容
  1. // Copyright (C) 2004 Team Python
  2. //  
  3. // This program is free software; you can redistribute it and/or modify
  4. // it under the terms of the GNU General Public License as published by
  5. // the Free Software Foundation; either version 2 of the License, or
  6. // (at your option) any later version.
  7. // 
  8. // This program is distributed in the hope that it will be useful,
  9. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11. // GNU General Public License for more details.
  12. // 
  13. // You should have received a copy of the GNU General Public License
  14. // along with this program; if not, write to the Free Software 
  15. // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17. // RealmListSrv.cpp: implementation of the RealmListSrv class.
  18. //
  19. //////////////////////////////////////////////////////////////////////
  21. #include "RealmListSrv.h"
  22. #include "Log.h"
  23. #include "Singleton.h"
  24. #include "Database.h"
  25. #include "Sockets.h"
  26. #include <sys/stat.h>
  27. #include <string>
  28. using namespace::std;
  30. #include "WorldServer.h"
  31. #define world WorldServer::getSingleton()
  34. //////////////////////////////////////////////////////////////////////
  35. // Construction/Destruction
  36. //////////////////////////////////////////////////////////////////////
  38. createFileSingleton( RealmListSrv );
  41. RealmListSrv::RealmListSrv( ) {
  42.     FILE * patchini = fopen( "patch.ini", "r" );
  43.     if( !patchini ) {
  44.         printf( "WARNING: patch.ini not found -- no client patching will be performed!" );
  45.     } else {
  46.         char redline[256];
  47.         uint32 buildnum; char * offset;
  48.         uint8 counter; char tempbyte[3]; tempbyte[2]=0;
  49.         while( fgets( redline, 256, patchini ) ) {
  50.             if( offset = strchr( redline, '=' ) ) {
  51.                 buildnum = atoi( redline );
  52.                 mPatches[ buildnum ] = new Patch();//uint8[ 16 ];
  53.                 strncpy( mPatches[ buildnum ]->Platform, offset - 3, 3 );
  54.                 mPatches[ buildnum ]->Platform[ 3 ] = 0;
  55.                 offset++;
  56.                 for( counter = 0; counter < 16; counter ++, offset += 2 ) {
  57.                     strncpy( tempbyte, offset, 2 );
  58.                     mPatches[ buildnum ]->Hash[ counter ] = (uint8)strtoul( tempbyte, NULL, 16 );
  59.                 }
  60.             }
  61.         }
  62.         fclose( patchini );
  63.     }
  64. }
  66. RealmListSrv::~RealmListSrv( ) {
  67.     for( RealmMap::iterator i = mRealms.begin( ); i != mRealms.end( ); ++ i ) {
  68.         delete i->second;
  69.     }
  70.     mRealms.clear( );
  71.     for( PatchMap::iterator i = mPatches.begin( ); i != mPatches.end( ); ++ i ) {
  72.         delete i->second;
  73.     }
  74.     mPatches.clear( );
  75. }
  77. void RealmListSrv::addRealm( char * name, char * address, uint8 icon, uint8 color, uint32 players ) {
  78.     removeRealm( name );
  79.     mRealms[ name ] = new Realm( );
  80.     mRealms[ name ]->address = address;
  81.     mRealms[ name ]->players = players;
  82. mRealms[ name ]->icon = icon;
  83. mRealms[ name ]->color = color;
  84. }
  86. void RealmListSrv::setRealm( char * name, uint8 icon, uint8 color, uint32 players ) {
  87.     if( mRealms.find( name ) != mRealms.end( ) )
  88.         mRealms[ name ]->players = players;
  89. if (icon!=2) mRealms[ name ]->icon = icon;
  90. if (color!=2) mRealms[ name ]->color = color;
  91. }
  93. void RealmListSrv::removeRealm( char * name ) {
  94.     if( mRealms.find( name ) != mRealms.end( ) ) {
  95.         delete mRealms[ name ];
  96.         mRealms.erase( name );
  97.     }
  98. }
  100. /* method to print realmlist */
  101. void RealmListSrv::printRealms()
  102. {
  103. RealmMap::iterator i;
  104. for( i = mRealms.begin( ); i != mRealms.end( ); ++ i )
  105. {
  106. printf("%s %dn",i->first.c_str(),i->second->players );
  107. }
  108. }
  110. enum opcode {
  111.     LOGON_CHALLENGE = 0x00, 
  112.     LOGON_PROOF = 0x01, 
  113.     RECONNECT_CHALLENGE = 0x02, 
  114.     RECONNECT_PROOF = 0x03, 
  115.     REALMLIST = 0x10,
  116. UPDATESRV = 0x04
  117. };
  120. void RealmListSrv::server_sockevent( nlink_server *cptr, uint16 revents, void *myNet ) {
  121. NetworkInterface * client;
  122. struct nlink_client *ncptr;
  123. if(revents & PF_READ)
  124. {
  125. client = ( ( NetworkInterface * ) myNet )->getConnection( );
  126. if (!client) 
  127. return;
  128. uint32 nonblockingstate = true;
  129. IOCTL_SOCKET( client->getSocketID(), IOCTL_NOBLOCK, &nonblockingstate );
  131. ncptr = new nlink_client;
  132. if(ncptr == NULL)
  133. return;
  134. memset(ncptr, 0, sizeof(*ncptr));
  135. ncptr->hdr.type = RCLIENT;
  136. ncptr->hdr.fd = client->getSocketID();
  138. nlink_insert((struct nlink *)ncptr);
  140. Client *pClient = new Client();
  141. pClient->BindNI(client);
  142. ncptr->pClient = pClient;
  143. }
  144. }
  146. void RealmListSrv::client_sockevent(struct nlink_client *cptr, unsigned short revents){
  148. if(revents & PF_READ)
  149. {
  150. RealmClient *pClient = static_cast < RealmClient * > ( cptr->pClient );
  151. NetworkInterface *net = pClient->getNetwork();
  152. uint8 opcode; 
  154. if (!net->isConnected()) {
  155. disconnect_client(cptr);
  156. return;
  157. }
  159. net->getData( 1, &opcode );
  160. if (!net->isConnected()) {
  161. disconnect_client(cptr);
  162. return;
  163. }
  164. switch( opcode ) {
  165. case LOGON_CHALLENGE:
  166. {
  167. Log::getSingleton( ).outString( "REALMLIST: Recieved LOGON_CHALLENGE" );
  168. uint8 unknown; uint16 length;
  169. char WoW[5]; uint8 byte1, byte2, byte3; uint16 client_version;
  170. char x86[5]; char Win[5]; char enUS[5];
  171. WoW[4] = x86[4] = Win[4] = enUS[4] = 0;
  172. uint8 wb1, wb2;
  173. int16 int1; uint32 int2; uint8 name_length; char name[256];
  174.                     
  175. net->getData( 1, &unknown );
  176. net->getData( 2, &length );
  177. net->getData( 4, WoW );
  178. net->getData( 1, &byte1 ); net->getData( 1, &byte2 ); net->getData( 1, &byte3 );
  179. net->getData( 2, &client_version );
  180. net->getData( 4, x86 ); net->getData( 4, Win ); net->getData( 4, enUS );
  181. net->getData( 1, &wb1 ); net->getData( 1, &wb2 );
  182. net->getData( 2, &int1 ); net->getData( 4, &int2 ); net->getData( 1, &name_length );
  183. if (!net->isConnected())
  184. break;
  185. net->getData( name_length, name );
  186. name[ name_length ] = 0;
  188. std::string cib;
  189. //printf( "Username: %sn", name );
  190. cib = WoW; std::reverse( cib.begin( ), cib.end( ) );
  191. //printf( "Game ID: %sn", cib.c_str( ) );
  192. //printf( "Version: %in", client_version );
  193. cib = x86; std::reverse( cib.begin( ), cib.end( ) );
  194. //printf( "Architecture: %sn", cib.c_str( ) );
  195. cib = Win; std::reverse( cib.begin( ), cib.end( ) );
  196. //printf( "Platform: %sn", cib.c_str( ) );
  197. cib = enUS; std::reverse( cib.begin( ), cib.end( ) );
  198. //printf( "Language: %sn", cib.c_str( ) );
  199. //printf( "Unknown Start Byte: %i n", unknown );
  200. //printf( "Unknown 3 Game Bytes: %i %i %i n", byte1, byte2, byte3 );
  201. //printf( "Unknown 2 Bytes: %i %in", wb1, wb2 );
  202. //printf( "Unknown 16bit Int: %in", int1 );
  203. //printf( "Unknown 32bit Int: %in", int2 );
  205.                     
  206. if( client_version != EXPECTED_WOW_CLIENT_BUILD ) {
  207. if( client_version < EXPECTED_WOW_CLIENT_BUILD ) {
  208. if( mPatches.find( client_version ) != mPatches.end( ) ) {
  209. char filnam[64]; 
  210. sprintf( filnam, "%i%s.mpq", client_version, mPatches[ client_version ]->Platform );
  211. FILE * patchfil = fopen( filnam, "rb" );
  212. if( patchfil ) {
  213. {
  214. uint8 newopcode = LOGON_PROOF;
  215. uint8 data[2] = { newopcode, 0x0a };
  216. net->sendData( 2, data );
  217. Log::getSingleton( ).outString( "REALMLIST: Sent LOGON_PROOF" );
  218. }
  219. {
  220. uint8 newopcode = '0';
  221. char * stringy = "Patch";
  222. uint8 stringling = strlen( stringy );
  223. //uint8 hash[] = { 0x7e, 0xf1, 0x34, 0x33, 0xf8, 0xd6, 0xe6, 0xc5, 0x58, 0x92, 0x72, 0x01, 0xae, 0xe8, 0x82, 0x39 };
  224. //uint8 hash[] = { 0x5b, 0x75, 0x24, 0x2d, 0x24, 0x5b, 0x0b, 0xa2, 0x74, 0xac, 0x92, 0xc5, 0xb3, 0xcc, 0x97, 0xfc };
  225. struct stat filestats;
  226. fstat( fileno( patchfil ), &filestats );
  227. uint64 filesize = filestats.st_size;
  228. net->sendData( 1, &newopcode );
  229. net->sendData( 1, &stringling );
  230. net->sendData( stringling, stringy );
  231. net->sendData( 8, &filesize );
  232. net->sendData( 16, mPatches[ client_version ]->Hash );
  233. Log::getSingleton( ).outString( "REALMLIST: Sent patch initialization" );
  234. }
  235. {
  236. uint8 newopcode;
  237. net->getData( 1, &newopcode );
  238. if( newopcode == '2' )
  239. Log::getSingleton( ).outString( "REALMLIST: Got patch acknowledgement" );
  240. else
  241. printf( "WEIRD PATCH RESPOnSE: '%c'n", newopcode );
  242. }
  243. {
  244. uint8 datablock[1500];
  245. uint16 datalen;
  246. uint8 newopcode = '1';
  247. Log::getSingleton( ).outString( "REALMLIST: Sending patch data...." );
  248. while( !feof( patchfil ) && net->isConnected( ) ) {
  249. datalen = fread( datablock, 1, 1500, patchfil );
  250. net->sendData( 1, &newopcode );
  251. net->sendData( 2, &datalen );
  252. net->sendData( datalen, datablock );
  253. }
  254. Log::getSingleton( ).outString( "REALMLIST: Done sending patch data." );
  255. }
  256. fclose( patchfil );
  257. } else {
  258. Log::getSingleton( ).outString( "REALMLIST: Error -- Failed to load patch mpq!" );
  259. }
  260. } else {
  261. Log::getSingleton( ).outString( "REALMLIST: Error -- No patch found to satisfy client version!" );
  262. }
  263. }
  265. uint8 tdata[] = { 0x01, 0x09 };
  266. net->sendData( sizeof( tdata ) , tdata );
  267. Log::getSingleton( ).outString( "REALMLIST: Sent LOGON_PROOF with rejection 'bad client version'" );
  268. break;
  269. } 
  273. // check if username and password exist
  274. DatabaseInterface *dbi = Database::getSingleton( ).createDatabaseInterface( );
  275. switch( dbi->Login( name, "BETA2", net->getIP() ) ) {
  276. case -1:   // bad password
  277. {
  278. uint8 tdata[] = { 0x01, 0x07 };
  279. net->sendData( sizeof( tdata ) , tdata );
  280. Log::getSingleton( ).outString( "REALMLIST: Sent LOGON_PROOF with rejection 'prepaid time used up'" );
  281. }break;
  282. case -2:   // general failure
  283. {
  284. uint8 tdata[] = { 0x01, 0x08 };
  285. net->sendData( sizeof( tdata ) , tdata );
  286. Log::getSingleton( ).outString( "REALMLIST: Sent LOGON_PROOF with rejection 'could not log in'" );
  287. }break;
  288. case -3:   // bad username
  289. {
  290. uint8 tdata[] = { 0x01, 0x03 };
  291. net->sendData( sizeof( tdata ) , tdata );
  292. Log::getSingleton( ).outString( "REALMLIST: Sent LOGON_PROOF with rejection 'account closed'" );
  293. }break;
  294. default:
  295. {
  296. uint8 newopcode = RECONNECT_PROOF;
  297. uint8 newdata = 0;
  298. uint8 data[2] = { newopcode, newdata };
  299. net->sendData(2, data);
  300. Log::getSingleton( ).outString( "REALMLIST: Sent RECONNECT_PROOF" );
  301. }break;
  302. }
  303. Database::getSingleton( ).removeDatabaseInterface( dbi );
  306. }break;
  307. case LOGON_PROOF:
  308. {
  309. Log::getSingleton( ).outString( "REALMLIST: Recieved LOGON_PROOF" );
  310. uint8 databuf[ 16*6+7 ];
  311. net->getData( 16*6+7, databuf );
  312. for( int i = 0; i < 16*6+7; i ++ ) {
  313. if( i % 16 == 0 )
  314. printf( "n" );
  315. printf( "%.2X ", databuf[i] );
  316. }
  317. printf ("n");
  321.                     
  322. uint8 newopcode = RECONNECT_PROOF;
  323. uint8 newdata = 0;
  324. uint8 data[2] = { newopcode, newdata };
  325. net->sendData(2, data);
  326. Log::getSingleton( ).outString( "REALMLIST: Sent RECONNECT_PROOF" );
  328. }break;
  329. case RECONNECT_CHALLENGE:
  330. {
  331. Log::getSingleton( ).outString( "REALMLIST: Recieved RECONNECT_CHALLENGE" );
  332. uint8 unknownbyte; uint16 datalen; 
  333. char WoW[5];  uint8 byte1, byte2, byte3; uint16 clientversion; char x86[5];
  334. char Win[5]; char enUS[5]; 
  335. uint8 ubyte1, ubyte2; int16 int1; uint32 int2;
  336. uint8 namelen; char name[256];
  337. net->getData( 1, &unknownbyte );
  338. net->getData( 2, &datalen );
  339. net->getData( 4, WoW ); WoW[4]=0;
  340. net->getData( 1, &byte1 ); net->getData( 1, &byte2 ); net->getData( 1, &byte3 );
  341. net->getData( 2, &clientversion );
  342. net->getData( 4, x86 ); x86[4]=0;
  343. net->getData( 4, Win ); Win[4]=0;
  344. net->getData( 4, enUS ); enUS[4]=0;
  345. //net->getData( 13, preuserdata );// ARGH
  346. net->getData( 1, &ubyte1 ); net->getData( 1, &ubyte2 ); net->getData( 2, &int1 );
  347. net->getData( 4, &int2 );
  348. net->getData( 1, &namelen );
  349. net->getData( namelen, name );
  350. name[ namelen ] = 0;
  351. //printf( "Username: %sn", name );
  352. std::string cib = WoW; std::reverse( cib.begin( ), cib.end( ) );
  353. //printf( "Game ID: %sn", cib.c_str( ) );
  354. //printf( "Version: %in", clientversion );
  355. cib = x86; std::reverse( cib.begin( ), cib.end( ) );
  356. //printf( "Architecture: %sn", cib.c_str( ) );
  357. cib = Win; std::reverse( cib.begin( ), cib.end( ) );
  358. //printf( "Platform: %sn", cib.c_str( ) );
  359. cib = enUS; std::reverse( cib.begin( ), cib.end( ) );
  360. //printf( "Language: %sn", cib.c_str( ) );
  361. //printf( "Unknown start byte: %in", unknownbyte );
  362. //printf( "3 game bytes: %i %i %in", byte1, byte2, byte3 );
  363. //printf( "Unknown 2 bytes: %i %in", ubyte1, ubyte2 );
  364. //printf( "Unknown 16bit int: %in", int1 );
  365. //printf( "Unknown 32bit int: %in", int2 );
  366. /*
  367. net->sendData( 1, &opcode );
  368. uint8 zerobyte = 0;
  369. for( int a = 0; a < 0x21; a ++ )
  370. net->sendData( 1, &zerobyte );
  371. */
  372. uint8 newopcode = RECONNECT_PROOF;
  373. uint8 newdata = 0;
  374. uint8 data[2] = { newopcode, newdata };
  375. net->sendData(2, data);
  376. Log::getSingleton( ).outString( "REALMLIST: Sent RECONNECT_CHALLENGE" );
  378. }break;
  379. case RECONNECT_PROOF:
  380. {
  381. Log::getSingleton( ).outString( "REALMLIST: Recieved RECONNECT_PROOF" );
  383. uint8 buf[5*16+7];
  384. net->getData( sizeof( buf), buf );
  386. uint8 newopcode = RECONNECT_PROOF;
  387. uint8 newdata = 0;
  388. uint8 data[2] = { newopcode, newdata };
  389. net->sendData(2, data);
  390. //                    net->sendData( 1, &newopcode );
  391. //                    net->sendData( 1, &newdata );
  392. Log::getSingleton( ).outString( "REALMLIST: Sent RECONNECT_PROOF" );
  393. }break;
  394. case REALMLIST:
  395. {
  396. Log::getSingleton( ).outString( "REALMLIST: Recieved REALMLIST request" );
  397. uint32 request; net->getData(4, &request );
  400. //format: uint16 datalen, uint32 request, uint8 numrealms
  401. //eachrealm: string name, string address, uint32 numplayers
  402. uint16 datalen = 7;
  403. RealmMap::iterator i;
  404. uint8 totalrealms = 0;
  405. for( i = mRealms.begin( ); i != mRealms.end( ); ++ i, ++totalrealms )
  406. datalen += i->first.length( ) + 1 + i->second->address.length( ) + 13;
  408. uint8 *data = new uint8[ datalen + 3 ];
  409. data[ 0 ] = REALMLIST;
  410. memcpy( data+1, &datalen, 2 );
  411. memcpy( data+3, &request, 4 );
  412. data[7]=totalrealms;
  413. int doo = 8;
  415. for( i = mRealms.begin( ); i != mRealms.end( ); ++ i ) {
  416. data[ doo++ ] = i->second->icon; 
  417. data[ doo++ ] = 0x00;
  418. data[ doo++ ] = 0x00;
  419. data[ doo++ ] = 0x00;
  420. data[ doo++ ] = i->second->color; 
  421. strcpy( (char *)data+doo, i->first.c_str( ) );
  422. doo+=i->first.length( )+1;
  423. strcpy( (char *)data+doo, i->second->address.c_str( ) );
  424. doo+=i->second->address.length( )+1;
  425. data[ doo++ ] = (uint8)(i->second->players & 255);
  426. data[ doo++ ] = (uint8)((i->second->players >> 8) & 255);
  427. data[ doo++ ] = (uint8)((i->second->players >> 16)& 255);
  428. data[ doo++ ] = (uint8)((i->second->players >> 24)& 255);
  429. data[ doo++ ] = (uint32)world.GetClientsConnected();
  430. // data[ doo++ ] = 0x64; // ping time (fake)
  431. data[ doo++ ] = 0x01;
  432. data[ doo++ ] = 0x02;
  433. }
  434. data[ doo++ ] = 0x00;
  435. data[ doo++ ] = 0x00;
  437. net->sendData( datalen + 3, data );
  438. Log::getSingleton( ).outString( "REALMLIST: Sent REALMLIST" );
  440. delete [] data;
  442. }break;
  443. case UPDATESRV:
  444. {
  445. char buf[256];
  446. char *realm;
  447. char *count;
  448. string rTemp = "";
  449. Log::getSingleton( ).outString( "REALMLIST: Recieved UPDATESRV request" );
  450. net->getData( 256, buf );
  451. realm = strtok(buf,";");
  452. count = strtok(0,";");
  453. rTemp="";
  454. rTemp.append(realm);
  455. // 2, 2 stands for unchanged icon and color
  456. this->setRealm( const_cast<char *>(rTemp.c_str()), 2, 2, atoi(count) );
  458. }break;
  459. default:
  460. {
  461. char debugchararray[256];
  462. sprintf( debugchararray, "REALMLIST: Recieved unknown opcode %i", opcode );
  463. Log::getSingleton( ).outString( debugchararray );
  465. }break;
  466. }
  468. }
  470. }
  472. void RealmListSrv::disconnect_client( struct nlink_client *cptr )
  473. {
  474. RealmClient * pClient = static_cast < RealmClient * > ( cptr->pClient );
  475. mClients.erase( pClient );
  476. delete pClient;
  477. Log::getSingleton( ).outString( "REALM: Socket Closed!" );
  478. Server::disconnect_client( cptr );
  479. }