void
game_usermsg(struct service* s, int id, void* msg, int sz) {
struct game* self = SERVICE_SELF;
struct gate_message* gm = msg;
assert(gm->c);
UM_CAST(UM_BASE, um, gm->msg);
switch (um->msgid) {
case IDUM_GAMELOGIN:
_login(self, gm->c, um);
break;
case IDUM_GAMELOGOUT:
_logout(self, gm->c, true, true);
break;
case IDUM_GAMELOADOK:
_loadok(self, gm->c);
break;
case IDUM_GAMESYNC:
_sync(self, gm->c, um);
break;
case IDUM_ROLEPRESS:
_role_press(self, gm->c, um);
break;
case IDUM_USEITEM:
_use_item(self, gm->c, um);
break;
}
}
int HLR2::activate(const char *msisdn)
{
LOG_INFO("%s::%s: msisdn: %s", __class__, __func__, msisdn);
if (0 > _login(msisdn)) {
LOG_ERROR("%s::%s: Unable to login!", __class__, __func__);
return -1;
}
//-- get imsi...
if (0 > _getIMSI()) {
LOG_ERROR("%s::%s: Unable to get IMSI information!", __class__, __func__);
_logout();
return -1;
}
for (int i = 0; i < (int)_activate_steps.size(); ++i) {
if (0 > (this->*_activate_steps[i].execute)()) {
for (int j = i; j >= 0; --j) {
if (0 > (this->*_activate_steps[j].rollback)()) {
LOG_ERROR("%s::%s: Failed: %s", __class__, __func__, this->_activate_steps[j].rollback_desc);
}
}
LOG_ERROR("%s::%s: Failed: %s", __class__, __func__, this->_activate_steps[i].execute_desc);
_logout();
return -1;
}
}
//-- successful
_logout();
return 0;
}
/* main */
int main(int argc, char * argv[])
{
int o;
char * user = NULL;
while((o = getopt(argc, argv, "")) != -1)
switch(o)
{
default:
return _login_usage();
}
if(optind != argc && optind + 1 != argc)
return _login_usage();
signal(SIGINT, SIG_IGN);
return _login(user) ? 0 : 2;
}
int HLR2::getIMSI(const char *msisdn, char *imsi, int imsi_size)
{
LOG_INFO("%s::%s: msisdn: %s", __class__, __func__, msisdn);
if (0 > _login(msisdn)) {
return -1;
}
int status = _getIMSI();
snprintf(imsi, imsi_size, "%s", _imsi.c_str());
LOG_DEBUG("%s::%s: msisdn: %s, imsi: %s", __class__, __func__, msisdn, imsi);
_logout();
return status;
}
char *Command::analyse(char *str)
{
Buff *_entry = new Buff();
_entry = Buffer::getValue(str);
// test
std::cout << _entry->magic << " ";
std::cout << (int)_entry->cmd << " ";
std::cout << _entry->size << " ";
std::cout << _entry->data << std::endl;
switch ((int)_entry->cmd)
{
case 101:
std::cout << "sending login" << std::endl;
return _login();
break;
case 103:
std::cout << _entry->data << std::endl;
break;
case 230:
std::cout << " Login deja existant" << std::endl;
break;
case 231:
std::cout << " Pas de data transmise" << std::endl;
break;
case 232:
std::cout << "Pas de login correspondant" << std::endl;
break;
case 234:
std::cout << "Deja en call" << std::endl;
break;
case 240:
std::cout << " Commande inconnue" << std::endl;
default: break;
}
return NULL;
}
int
main(int argc, char *argv[]) {
if (argc == 1)
helpAndLeave(argv[0], EXIT_FAILURE);
char *username = argv[1];
if (argc > 2)
utmp_file = argv[2];
if (argc > 3)
wtmp_file = argv[3];
utmpname(utmp_file);
struct utmpx ut;
strncpy(ut.ut_user, username, __UT_NAMESIZE);
_login(&ut);
printf("Username %s has been logged in.\n", username);
exit(EXIT_SUCCESS);
}
bool IPacketReceiver::handlePacket(IWorldPlayer *_player)
{
FDASSERT(_player);
CByteArray &t_packet = _player->getClient()->incoming();
s32 t_command = IPacketReader::readWorldHeader(t_packet);
//handle the command
switch (t_command)
{
case 0x001a:
return _sendMail(_player);
case 0x001b:
return _mailDelete(_player);
case 0x001c:
return _mailTakeItem(_player);
case 0x001d:
return _mailBox(_player);
case 0x001f:
return _mailTakeMoney(_player);
case 0x0024:
return _mailRead(_player);
case 0xff00:
return _login(_player);
case 0x0f0003:
return _skillChange(_player);
case 0xff0000:
return _chat(_player);
case 0xff0006:
return _invMoveItem(_player);
case 0xff0007:
return _invDropItem(_player);
case 0xff0010:
case 0xff0011:
case 0xff0012:
return _attack(_player);
case 0xff000b:
return _invUnequip(_player);
case 0xff0019:
return _invDeleteItem(_player);
case 0xff0021:
return _useItem(_player);
case 0xff0022:
return _unknown_1(_player);
case 0xff0023:
return _targetChange(_player);
case 0xff00a7:
return _trade(_player);
case 0xff00a9:
return _shopOpen(_player);
case 0xff00aa:
return _shopClose(_player);
case 0xff00ab:
return _shopAddItem(_player);
case 0xff00ae:
return _shopRemoveItem(_player);
case 0xff00b0:
return _talkToNpc(_player);
case 0xff00b1:
return _tradeNpc(_player);
case 0xff00b3:
return _buyNpc(_player);
case 0xff00b4:
return _sellNpc(_player);
case 0xff00c1:
return _loadStar(_player);
case 0xff00d2:
return _unknown_0(_player);
case 0x70000004:
return _specialOptionScroll(_player);
case 0xf000b04e:
return _request_ranking_guild(_player);
case 0xf000b024:
case 0xf000f113:
return _upgrade(_player);
case 0xf000b055:
return _shopChat(_player);
case 0xf000b058:
return _shopChatEnter(_player);
case 0xf000b059:
return _shopChatLeave(_player);
case 0xf000d022:
return _in_GuildCombat(_player);
case 0xf000f009:
return _viewEquipment(_player);
case 0xf000f501:
return _statChange(_player);
case 0xf000f802:
return _characterInfos(_player);
case 0xf000f813:
return _buffEvent(_player);
case 0xffffff00:
return _mouseControl(_player);
case 0xffffff01:
return _keyboardControl(_player);
case 0xffffff02:
return _motion(_player);
case 0xffffff07:
return _follow(_player);
case 0xffffff08:
return _querygetpos(_player);
case 0xffffff09:
return _getpos(_player);
case 0xffffff11:
return _partyAccept(_player);
case 0xffffff17:
return _partyInvitation(_player);
case 0xffffff18:
return _partyReject(_player);
case 0xffffff61:
return _addFriendPerClick(_player);
case 0xffffff67:
return _messengerStatus(_player);
case 0xffffff6b:
return _addFriend(_player);
case 0xffffff7c:
return _cheer(_player);
case 0:
Log::write(LOG_WARNING, "Packet client Invalide");
#ifdef SDEBUG
t_packet.saveFormatted("_invalide_packets.txt");
#endif
return false;
default:
Log::write(LOG_DEBUG, "Packet inconnue Recu 0x%x", t_command);
#ifdef SDEBUG
sprintf(m_buffer, "logs/_inconnue_%x.txt", t_command);
t_packet.saveFormatted(m_buffer);
#endif
return false;
}
return !t_packet.end();
}
bool RealmConnection::connect()
{
UT_DEBUGMSG(("RealmConnection::connect()\n"));
UT_return_val_if_fail(!m_thread_ptr, false);
try {
std::string address = m_address;
int port = m_port;
if (m_tls)
{
// setup our local TLS tunnel to the realm
m_tls_tunnel_ptr.reset(new tls_tunnel::ClientProxy(m_address, m_port, m_ca_file, false));
m_tls_tunnel_ptr->setup();
asio::thread thread(boost::bind(&tls_tunnel::ClientProxy::run, m_tls_tunnel_ptr));
// make sure we connect to the tunnel, and not directly to the realm
address = m_tls_tunnel_ptr->local_address();
port = m_tls_tunnel_ptr->local_port();
}
// connect!
asio::ip::tcp::resolver::query query(address, boost::lexical_cast<std::string>(port));
asio::ip::tcp::resolver resolver(m_io_service);
asio::ip::tcp::resolver::iterator iterator(resolver.resolve(query));
bool connected = false;
asio::error_code error_code;
while (iterator != asio::ip::tcp::resolver::iterator())
{
try
{
m_socket.connect(*iterator);
connected = true;
break;
}
catch (asio::system_error se)
{
error_code = se.code();
try { m_socket.close(); } catch(...) {}
}
iterator++;
}
if (!connected)
{
UT_DEBUGMSG(("Error connecting to realm: %s", asio::system_error(error_code).what()));
return false;
}
}
catch (tls_tunnel::Exception& e)
{
UT_DEBUGMSG(("tls_tunnel exception connecting to realm: %s\n", e.message().c_str()));
return false;
}
catch (asio::system_error& se)
{
UT_DEBUGMSG(("Error connecting to realm: %s\n", se.what()));
return false;
}
catch (...)
{
UT_DEBUGMSG(("Error connecting to realm!\n"));
return false;
}
if (!_login())
{
UT_DEBUGMSG(("RealmConnection login failed!\n"));
_disconnect();
return false;
}
UT_DEBUGMSG(("RealmConnection connected\n"));
// start reading realm messages
_receive();
m_thread_ptr.reset(new asio::thread(boost::bind(&asio::io_service::run, &m_io_service)));
return true;
}
