// Copyright (c) Athena Dev Teams - Licensed under GNU GPL // For more information, see LICENCE in the main folder #include "../common/cbasetypes.h" #include "../common/malloc.h" #include "../common/socket.h" #include "../common/timer.h" #include "../common/nullpo.h" #include "../common/showmsg.h" #include "../common/strlib.h" #include "../common/ers.h" #include "map.h" #include "battle.h" #include "clif.h" #include "intif.h" #include "npc.h" #include "pc.h" #include "pet.h" #include "skill.h" #include "status.h" #include "homunculus.h" #include "instance.h" #include "mercenary.h" #include "elemental.h" #include "chrif.h" #include "quest.h" #include "storage.h" #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/types.h> #include <time.h> static int check_connect_char_server(int tid, unsigned int tick, int id, intptr_t data); static struct eri *auth_db_ers; //For reutilizing player login structures. static DBMap* auth_db; // int id -> struct auth_node* static const int packet_len_table[0x3d] = { // U - used, F - free 60, 3,-1,27,10,-1, 6,-1, // 2af8-2aff: U->2af8, U->2af9, U->2afa, U->2afb, U->2afc, U->2afd, U->2afe, U->2aff 6,-1,18, 7,-1,39,30, 10, // 2b00-2b07: U->2b00, U->2b01, U->2b02, U->2b03, U->2b04, U->2b05, U->2b06, U->2b07 6,30, 0, 0,86, 7,44,34, // 2b08-2b0f: U->2b08, U->2b09, F->2b0a, F->2b0b, U->2b0c, U->2b0d, U->2b0e, U->2b0f 11,10,10, 0,11, 0,266,10, // 2b10-2b17: U->2b10, U->2b11, U->2b12, F->2b13, U->2b14, F->2b15, U->2b16, U->2b17 2,10, 2,-1,-1,-1, 2, 7, // 2b18-2b1f: U->2b18, U->2b19, U->2b1a, U->2b1b, U->2b1c, U->2b1d, U->2b1e, U->2b1f -1,10, 8, 2, 2,14,19,19, // 2b20-2b27: U->2b20, U->2b21, U->2b22, U->2b23, U->2b24, U->2b25, U->2b26, U->2b27 }; //Used Packets: //2af8: Outgoing, chrif_connect -> 'connect to charserver / auth @ charserver' //2af9: Incoming, chrif_connectack -> 'answer of the 2af8 login(ok / fail)' //2afa: Outgoing, chrif_sendmap -> 'sending our maps' //2afb: Incoming, chrif_sendmapack -> 'Maps received successfully / or not ..' //2afc: Outgoing, chrif_scdata_request -> request sc_data for pc_authok'ed char. <- new command reuses previous one. //2afd: Incoming, chrif_authok -> 'client authentication ok' //2afe: Outgoing, send_usercount_tochar -> 'sends player count of this map server to charserver' //2aff: Outgoing, send_users_tochar -> 'sends all actual connected character ids to charserver' //2b00: Incoming, map_setusers -> 'set the actual usercount? PACKET.2B COUNT.L.. ?' (not sure) //2b01: Outgoing, chrif_save -> 'charsave of char XY account XY (complete struct)' //2b02: Outgoing, chrif_charselectreq -> 'player returns from ingame to charserver to select another char.., this packets includes sessid etc' ? (not 100% sure) //2b03: Incoming, clif_charselectok -> '' (i think its the packet after enterworld?) (not sure) //2b04: Incoming, chrif_recvmap -> 'getting maps from charserver of other mapserver's' //2b05: Outgoing, chrif_changemapserver -> 'Tell the charserver the mapchange / quest for ok...' //2b06: Incoming, chrif_changemapserverack -> 'awnser of 2b05, ok/fail, data: dunno^^' //2b07: Outgoing, chrif_removefriend -> 'Tell charserver to remove friend_id from char_id friend list' //2b08: Outgoing, chrif_searchcharid -> '...' //2b09: Incoming, map_addchariddb -> 'Adds a name to the nick db' //2b0a: FREE //2b0b: FREE //2b0c: Outgoing, chrif_changeemail -> 'change mail address ...' //2b0d: Incoming, chrif_changedsex -> 'Change sex of acc XY' //2b0e: Outgoing, chrif_char_ask_name -> 'Do some operations (change sex, ban / unban etc)' //2b0f: Incoming, chrif_char_ask_name_answer -> 'answer of the 2b0e' //2b10: Outgoing, chrif_updatefamelist -> 'Update the fame ranking lists and send them' //2b11: Outgoing, chrif_divorce -> 'tell the charserver to do divorce' //2b12: Incoming, chrif_divorceack -> 'divorce chars //2b13: FREE //2b14: Incoming, chrif_accountban -> 'not sure: kick the player with message XY' //2b15: FREE //2b16: Outgoing, chrif_ragsrvinfo -> 'sends base / job / drop rates ....' //2b17: Outgoing, chrif_char_offline -> 'tell the charserver that the char is now offline' //2b18: Outgoing, chrif_char_reset_offline -> 'set all players OFF!' //2b19: Outgoing, chrif_char_online -> 'tell the charserver that the char .. is online' //2b1a: Outgoing, chrif_buildfamelist -> 'Build the fame ranking lists and send them' //2b1b: Incoming, chrif_recvfamelist -> 'Receive fame ranking lists' //2b1c: Outgoing, chrif_save_scdata -> 'Send sc_data of player for saving.' //2b1d: Incoming, chrif_load_scdata -> 'received sc_data of player for loading.' //2b1e: Incoming, chrif_update_ip -> 'Reqest forwarded from char-server for interserver IP sync.' [Lance] //2b1f: Incoming, chrif_disconnectplayer -> 'disconnects a player (aid X) with the message XY ... 0x81 ..' [Sirius] //2b20: Incoming, chrif_removemap -> 'remove maps of a server (sample: its going offline)' [Sirius] //2b21: Incoming, chrif_save_ack. Returned after a character has been "final saved" on the char-server. [Skotlex] //2b22: Incoming, chrif_updatefamelist_ack. Updated one position in the fame list. //2b23: Outgoing, chrif_keepalive. charserver ping. //2b24: Incoming, chrif_keepalive_ack. charserver ping reply. //2b25: Incoming, chrif_deadopt -> 'Removes baby from Father ID and Mother ID' //2b26: Outgoing, chrif_authreq -> 'client authentication request' //2b27: Incoming, chrif_authfail -> 'client authentication failed' int chrif_connected = 0; int char_fd = -1; int srvinfo; static char char_ip_str[128]; static uint32 char_ip = 0; static uint16 char_port = 6121; static char userid[NAME_LENGTH], passwd[NAME_LENGTH]; static int chrif_state = 0; int other_mapserver_count=0; //Holds count of how many other map servers are online (apart of this instance) [Skotlex] //Interval at which map server updates online listing. [Valaris] #define CHECK_INTERVAL 3600000 //Interval at which map server sends number of connected users. [Skotlex] #define UPDATE_INTERVAL 10000 //This define should spare writing the check in every function. [Skotlex] #define chrif_check(a) { if(!chrif_isconnected()) return a; } /// Resets all the data. void chrif_reset(void) { // TODO kick everyone out and reset everything [FlavioJS] exit(EXIT_FAILURE); } /// Checks the conditions for the server to stop. /// Releases the cookie when all characters are saved. /// If all the conditions are met, it stops the core loop. void chrif_check_shutdown(void) { if( runflag != MAPSERVER_ST_SHUTDOWN ) return; if( auth_db->size(auth_db) > 0 ) return; runflag = CORE_ST_STOP; } struct auth_node* chrif_search(int account_id) { return (struct auth_node*)idb_get(auth_db, account_id); } struct auth_node* chrif_auth_check(int account_id, int char_id, enum sd_state state) { struct auth_node *node = chrif_search(account_id); return ( node && node->char_id == char_id && node->state == state ) ? node : NULL; } bool chrif_auth_delete(int account_id, int char_id, enum sd_state state) { struct auth_node *node; if ( (node = chrif_auth_check(account_id, char_id, state) ) ) { int fd = node->sd ? node->sd->fd : node->fd; if ( session[fd] && session[fd]->session_data == node->sd ) session[fd]->session_data = NULL; if ( node->char_dat ) aFree(node->char_dat); if ( node->sd ) aFree(node->sd); ers_free(auth_db_ers, node); idb_remove(auth_db,account_id); return true; } return false; } //Moves the sd character to the auth_db structure. static bool chrif_sd_to_auth(TBL_PC* sd, enum sd_state state) { struct auth_node *node; if ( chrif_search(sd->status.account_id) ) return false; //Already exists? node = ers_alloc(auth_db_ers, struct auth_node); memset(node, 0, sizeof(struct auth_node)); node->account_id = sd->status.account_id; node->char_id = sd->status.char_id; node->login_id1 = sd->login_id1; node->login_id2 = sd->login_id2; node->sex = sd->status.sex; node->fd = sd->fd; node->sd = sd; //Data from logged on char. node->node_created = gettick(); //timestamp for node timeouts node->state = state; sd->state.active = 0; idb_put(auth_db, node->account_id, node); return true; } static bool chrif_auth_logout(TBL_PC* sd, enum sd_state state) { if(sd->fd && state == ST_LOGOUT) { //Disassociate player, and free it after saving ack returns. [Skotlex] //fd info must not be lost for ST_MAPCHANGE as a final packet needs to be sent to the player. if ( session[sd->fd] ) session[sd->fd]->session_data = NULL; sd->fd = 0; } return chrif_sd_to_auth(sd, state); } bool chrif_auth_finished(TBL_PC* sd) { struct auth_node *node= chrif_search(sd->status.account_id); if ( node && node->sd == sd && node->state == ST_LOGIN ) { node->sd = NULL; return chrif_auth_delete(node->account_id, node->char_id, ST_LOGIN); } return false; } // sets char-server's user id void chrif_setuserid(char *id) { memcpy(userid, id, NAME_LENGTH); } // sets char-server's password void chrif_setpasswd(char *pwd) { memcpy(passwd, pwd, NAME_LENGTH); } // security check, prints warning if using default password void chrif_checkdefaultlogin(void) { if (strcmp(userid, "s1")==0 && strcmp(passwd, "p1")==0) { ShowWarning("Using the default user/password s1/p1 is NOT RECOMMENDED.\n"); ShowNotice("Please edit your 'login' table to create a proper inter-server user/password (gender 'S')\n"); ShowNotice("and then edit your user/password in conf/map_athena.conf (or conf/import/map_conf.txt)\n"); } } // sets char-server's ip address int chrif_setip(const char* ip) { char ip_str[16]; if ( !( char_ip = host2ip(ip) ) ) { ShowWarning("Failed to Resolve Char Server Address! (%s)\n", ip); return 0; } strncpy(char_ip_str, ip, sizeof(char_ip_str)); ShowInfo("Char Server IP Address : '"CL_WHITE"%s"CL_RESET"' -> '"CL_WHITE"%s"CL_RESET"'.\n", ip, ip2str(char_ip, ip_str)); return 1; } // sets char-server's port number void chrif_setport(uint16 port) { char_port = port; } // says whether the char-server is connected or not int chrif_isconnected(void) { return (char_fd > 0 && session[char_fd] != NULL && chrif_state == 2); } /*========================================== * Saves character data. * Flag = 1: Character is quitting * Flag = 2: Character is changing map-servers *------------------------------------------*/ int chrif_save(struct map_session_data *sd, int flag) { nullpo_retr(-1, sd); pc_makesavestatus(sd); if (flag && sd->state.active) { //Store player data which is quitting //FIXME: SC are lost if there's no connection at save-time because of the way its related data is cleared immediately after this function. [Skotlex] if ( chrif_isconnected() ) chrif_save_scdata(sd); if ( !chrif_auth_logout(sd,flag == 1 ? ST_LOGOUT : ST_MAPCHANGE) ) ShowError("chrif_save: Failed to set up player %d:%d for proper quitting!\n", sd->status.account_id, sd->status.char_id); } chrif_check(-1); //Character is saved on reconnect. //For data sync if (sd->state.storage_flag == 2) storage_guild_storagesave(sd->status.account_id, sd->status.guild_id, flag); if (flag) sd->state.storage_flag = 0; //Force close it. //Saving of registry values. if (sd->state.reg_dirty&4) intif_saveregistry(sd, 3); //Save char regs if (sd->state.reg_dirty&2) intif_saveregistry(sd, 2); //Save account regs if (sd->state.reg_dirty&1) intif_saveregistry(sd, 1); //Save account2 regs WFIFOHEAD(char_fd, sizeof(sd->status) + 13); WFIFOW(char_fd,0) = 0x2b01; WFIFOW(char_fd,2) = sizeof(sd->status) + 13; WFIFOL(char_fd,4) = sd->status.account_id; WFIFOL(char_fd,8) = sd->status.char_id; WFIFOB(char_fd,12) = (flag==1)?1:0; //Flag to tell char-server this character is quitting. memcpy(WFIFOP(char_fd,13), &sd->status, sizeof(sd->status)); WFIFOSET(char_fd, WFIFOW(char_fd,2)); if( sd->status.pet_id > 0 && sd->pd ) intif_save_petdata(sd->status.account_id,&sd->pd->pet); if( sd->hd && merc_is_hom_active(sd->hd) ) merc_save(sd->hd); if( sd->md && mercenary_get_lifetime(sd->md) > 0 ) mercenary_save(sd->md); if( sd->ed && elemental_get_lifetime(sd->ed) > 0 ) elemental_save(sd->ed); if( sd->save_quest ) intif_quest_save(sd); return 0; } // connects to char-server (plaintext) int chrif_connect(int fd) { ShowStatus("Logging in to char server...\n", char_fd); WFIFOHEAD(fd,60); WFIFOW(fd,0) = 0x2af8; memcpy(WFIFOP(fd,2), userid, NAME_LENGTH); memcpy(WFIFOP(fd,26), passwd, NAME_LENGTH); WFIFOL(fd,50) = 0; WFIFOL(fd,54) = htonl(clif_getip()); WFIFOW(fd,58) = htons(clif_getport()); WFIFOSET(fd,60); return 0; } // sends maps to char-server int chrif_sendmap(int fd) { int i; ShowStatus("Sending maps to char server...\n"); // Sending normal maps, not instances WFIFOHEAD(fd, 4 + instance_start * 4); WFIFOW(fd,0) = 0x2afa; for(i = 0; i < instance_start; i++) WFIFOW(fd,4+i*4) = map[i].index; WFIFOW(fd,2) = 4 + i * 4; WFIFOSET(fd,WFIFOW(fd,2)); return 0; } // receive maps from some other map-server (relayed via char-server) int chrif_recvmap(int fd) { int i, j; uint32 ip = ntohl(RFIFOL(fd,4)); uint16 port = ntohs(RFIFOW(fd,8)); for(i = 10, j = 0; i < RFIFOW(fd,2); i += 4, j++) { map_setipport(RFIFOW(fd,i), ip, port); } if (battle_config.etc_log) ShowStatus("Received maps from %d.%d.%d.%d:%d (%d maps)\n", CONVIP(ip), port, j); other_mapserver_count++; return 0; } // remove specified maps (used when some other map-server disconnects) int chrif_removemap(int fd) { int i, j; uint32 ip = RFIFOL(fd,4); uint16 port = RFIFOW(fd,8); for(i = 10, j = 0; i < RFIFOW(fd, 2); i += 4, j++) map_eraseipport(RFIFOW(fd, i), ip, port); other_mapserver_count--; if(battle_config.etc_log) ShowStatus("remove map of server %d.%d.%d.%d:%d (%d maps)\n", CONVIP(ip), port, j); return 0; } // received after a character has been "final saved" on the char-server static void chrif_save_ack(int fd) { chrif_auth_delete(RFIFOL(fd,2), RFIFOL(fd,6), ST_LOGOUT); chrif_check_shutdown(); } // request to move a character between mapservers int chrif_changemapserver(struct map_session_data* sd, uint32 ip, uint16 port) { nullpo_retr(-1, sd); if (other_mapserver_count < 1) {//No other map servers are online! clif_authfail_fd(sd->fd, 0); return -1; } chrif_check(-1); WFIFOHEAD(char_fd,35); WFIFOW(char_fd, 0) = 0x2b05; WFIFOL(char_fd, 2) = sd->bl.id; WFIFOL(char_fd, 6) = sd->login_id1; WFIFOL(char_fd,10) = sd->login_id2; WFIFOL(char_fd,14) = sd->status.char_id; WFIFOW(char_fd,18) = sd->mapindex; WFIFOW(char_fd,20) = sd->bl.x; WFIFOW(char_fd,22) = sd->bl.y; WFIFOL(char_fd,24) = htonl(ip); WFIFOW(char_fd,28) = htons(port); WFIFOB(char_fd,30) = sd->status.sex; WFIFOL(char_fd,31) = htonl(session[sd->fd]->client_addr); WFIFOL(char_fd,35) = sd->group_id; WFIFOSET(char_fd,39); return 0; } /// map-server change request acknowledgement (positive or negative) /// R 2b06 <account_id>.L <login_id1>.L <login_id2>.L <char_id>.L <map_index>.W <x>.W <y>.W <ip>.L <port>.W int chrif_changemapserverack(int account_id, int login_id1, int login_id2, int char_id, short map_index, short x, short y, uint32 ip, uint16 port) { struct auth_node *node; if ( !( node = chrif_auth_check(account_id, char_id, ST_MAPCHANGE) ) ) return -1; if ( !login_id1 ) { ShowError("map server change failed.\n"); clif_authfail_fd(node->fd, 0); } else clif_changemapserver(node->sd, map_index, x, y, ntohl(ip), ntohs(port)); //Player has been saved already, remove him from memory. [Skotlex] chrif_auth_delete(account_id, char_id, ST_MAPCHANGE); return 0; } /*========================================== * *------------------------------------------*/ int chrif_connectack(int fd) { static bool char_init_done = false; if (RFIFOB(fd,2)) { ShowFatalError("Connection to char-server failed %d.\n", RFIFOB(fd,2)); exit(EXIT_FAILURE); } ShowStatus("Successfully logged on to Char Server (Connection: '"CL_WHITE"%d"CL_RESET"').\n",fd); chrif_state = 1; chrif_connected = 1; chrif_sendmap(fd); ShowStatus("Event '"CL_WHITE"OnInterIfInit"CL_RESET"' executed with '"CL_WHITE"%d"CL_RESET"' NPCs.\n", npc_event_doall("OnInterIfInit")); if( !char_init_done ) { char_init_done = true; ShowStatus("Event '"CL_WHITE"OnInterIfInitOnce"CL_RESET"' executed with '"CL_WHITE"%d"CL_RESET"' NPCs.\n", npc_event_doall("OnInterIfInitOnce")); guild_castle_map_init(); } return 0; } /** * @see DBApply */ static int chrif_reconnect(DBKey key, DBData *data, va_list ap) { struct auth_node *node = db_data2ptr(data); switch (node->state) { case ST_LOGIN: if ( node->sd && node->char_dat == NULL ) {//Since there is no way to request the char auth, make it fail. pc_authfail(node->sd); chrif_char_offline(node->sd); chrif_auth_delete(node->account_id, node->char_id, ST_LOGIN); } break; case ST_LOGOUT: //Re-send final save chrif_save(node->sd, 1); break; case ST_MAPCHANGE: { //Re-send map-change request. struct map_session_data *sd = node->sd; uint32 ip; uint16 port; if( map_mapname2ipport(sd->mapindex,&ip,&port) == 0 ) chrif_changemapserver(sd, ip, port); else //too much lag/timeout is the closest explanation for this error. clif_authfail_fd(sd->fd, 3); break; } } return 0; } /// Called when all the connection steps are completed. void chrif_on_ready(void) { ShowStatus("Map Server is now online.\n"); chrif_state = 2; chrif_check_shutdown(); //If there are players online, send them to the char-server. [Skotlex] send_users_tochar(); //Auth db reconnect handling auth_db->foreach(auth_db,chrif_reconnect); //Re-save any storages that were modified in the disconnection time. [Skotlex] do_reconnect_storage(); //Re-save any guild castles that were modified in the disconnection time. guild_castle_reconnect(-1, 0, 0); } /*========================================== * *------------------------------------------*/ int chrif_sendmapack(int fd) { if (RFIFOB(fd,2)) { ShowFatalError("chrif : send map list to char server failed %d\n", RFIFOB(fd,2)); exit(EXIT_FAILURE); } memcpy(wisp_server_name, RFIFOP(fd,3), NAME_LENGTH); chrif_on_ready(); return 0; } /*========================================== * Request sc_data from charserver [Skotlex] *------------------------------------------*/ int chrif_scdata_request(int account_id, int char_id) { #ifdef ENABLE_SC_SAVING chrif_check(-1); WFIFOHEAD(char_fd,10); WFIFOW(char_fd,0) = 0x2afc; WFIFOL(char_fd,2) = account_id; WFIFOL(char_fd,6) = char_id; WFIFOSET(char_fd,10); #endif return 0; } /*========================================== * Request auth confirmation *------------------------------------------*/ void chrif_authreq(struct map_session_data *sd) { struct auth_node *node= chrif_search(sd->bl.id); if( node != NULL || !chrif_isconnected() ) { set_eof(sd->fd); return; } WFIFOHEAD(char_fd,19); WFIFOW(char_fd,0) = 0x2b26; WFIFOL(char_fd,2) = sd->status.account_id; WFIFOL(char_fd,6) = sd->status.char_id; WFIFOL(char_fd,10) = sd->login_id1; WFIFOB(char_fd,14) = sd->status.sex; WFIFOL(char_fd,15) = htonl(session[sd->fd]->client_addr); WFIFOSET(char_fd,19); chrif_sd_to_auth(sd, ST_LOGIN); } /*========================================== * Auth confirmation ack *------------------------------------------*/ void chrif_authok(int fd) { int account_id, group_id, char_id; uint32 login_id1,login_id2; time_t expiration_time; struct mmo_charstatus* status; struct auth_node *node; bool changing_mapservers; TBL_PC* sd; //Check if both servers agree on the struct's size if( RFIFOW(fd,2) - 25 != sizeof(struct mmo_charstatus) ) { ShowError("chrif_authok: Data size mismatch! %d != %d\n", RFIFOW(fd,2) - 25, sizeof(struct mmo_charstatus)); return; } account_id = RFIFOL(fd,4); login_id1 = RFIFOL(fd,8); login_id2 = RFIFOL(fd,12); expiration_time = (time_t)(int32)RFIFOL(fd,16); group_id = RFIFOL(fd,20); changing_mapservers = (RFIFOB(fd,24)); status = (struct mmo_charstatus*)RFIFOP(fd,25); char_id = status->char_id; //Check if we don't already have player data in our server //Causes problems if the currently connected player tries to quit or this data belongs to an already connected player which is trying to re-auth. if ( ( sd = map_id2sd(account_id) ) != NULL ) return; if ( ( node = chrif_search(account_id) ) == NULL ) return; // should not happen if ( node->state != ST_LOGIN ) return; //character in logout phase, do not touch that data. if ( node->sd == NULL ) { /* //When we receive double login info and the client has not connected yet, //discard the older one and keep the new one. chrif_auth_delete(node->account_id, node->char_id, ST_LOGIN); */ return; // should not happen } sd = node->sd; if( runflag == MAPSERVER_ST_RUNNING && node->char_dat == NULL && node->account_id == account_id && node->char_id == char_id && node->login_id1 == login_id1 ) { //Auth Ok if (pc_authok(sd, login_id2, expiration_time, group_id, status, changing_mapservers)) return; } else { //Auth Failed pc_authfail(sd); } chrif_char_offline(sd); //Set him offline, the char server likely has it set as online already. chrif_auth_delete(account_id, char_id, ST_LOGIN); } // client authentication failed void chrif_authfail(int fd) {/* HELLO WORLD. ip in RFIFOL 15 is not being used (but is available) */ int account_id, char_id; uint32 login_id1; char sex; struct auth_node* node; account_id = RFIFOL(fd,2); char_id = RFIFOL(fd,6); login_id1 = RFIFOL(fd,10); sex = RFIFOB(fd,14); node = chrif_search(account_id); if( node != NULL && node->account_id == account_id && node->char_id == char_id && node->login_id1 == login_id1 && node->sex == sex && node->state == ST_LOGIN ) {// found a match clif_authfail_fd(node->fd, 0); chrif_auth_delete(account_id, char_id, ST_LOGIN); } } /** * This can still happen (client times out while waiting for char to confirm auth data) * @see DBApply */ int auth_db_cleanup_sub(DBKey key, DBData *data, va_list ap) { struct auth_node *node = db_data2ptr(data); const char* states[] = { "Login", "Logout", "Map change" }; if(DIFF_TICK(gettick(),node->node_created)>60000) { switch (node->state) { case ST_LOGOUT: //Re-save attempt (->sd should never be null here). node->node_created = gettick(); //Refresh tick (avoid char-server load if connection is really bad) chrif_save(node->sd, 1); break; default: //Clear data. any connected players should have timed out by now. ShowInfo("auth_db: Node (state %s) timed out for %d:%d\n", states[node->state], node->account_id, node->char_id); chrif_char_offline_nsd(node->account_id, node->char_id); chrif_auth_delete(node->account_id, node->char_id, node->state); break; } return 1; } return 0; } int auth_db_cleanup(int tid, unsigned int tick, int id, intptr_t data) { chrif_check(0); auth_db->foreach(auth_db, auth_db_cleanup_sub); return 0; } /*========================================== * *------------------------------------------*/ int chrif_charselectreq(struct map_session_data* sd, uint32 s_ip) { nullpo_retr(-1, sd); if( !sd || !sd->bl.id || !sd->login_id1 ) return -1; chrif_check(-1); WFIFOHEAD(char_fd,18); WFIFOW(char_fd, 0) = 0x2b02; WFIFOL(char_fd, 2) = sd->bl.id; WFIFOL(char_fd, 6) = sd->login_id1; WFIFOL(char_fd,10) = sd->login_id2; WFIFOL(char_fd,14) = htonl(s_ip); WFIFOSET(char_fd,18); return 0; } /*========================================== * Search Char trough id on char serv *------------------------------------------*/ int chrif_searchcharid(int char_id) { if( !char_id ) return -1; chrif_check(-1); WFIFOHEAD(char_fd,6); WFIFOW(char_fd,0) = 0x2b08; WFIFOL(char_fd,2) = char_id; WFIFOSET(char_fd,6); return 0; } /*========================================== * Change Email *------------------------------------------*/ int chrif_changeemail(int id, const char *actual_email, const char *new_email) { if (battle_config.etc_log) ShowInfo("chrif_changeemail: account: %d, actual_email: '%s', new_email: '%s'.\n", id, actual_email, new_email); chrif_check(-1); WFIFOHEAD(char_fd,86); WFIFOW(char_fd,0) = 0x2b0c; WFIFOL(char_fd,2) = id; memcpy(WFIFOP(char_fd,6), actual_email, 40); memcpy(WFIFOP(char_fd,46), new_email, 40); WFIFOSET(char_fd,86); return 0; } /*========================================== * S 2b0e <accid>.l <name>.24B <type>.w { <year>.w <month>.w <day>.w <hour>.w <minute>.w <second>.w } * Send an account modification request to the login server (via char server). * type of operation: * 1: block, 2: ban, 3: unblock, 4: unban, 5: changesex (use next function for 5) *------------------------------------------*/ int chrif_char_ask_name(int acc, const char* character_name, unsigned short operation_type, int year, int month, int day, int hour, int minute, int second) { chrif_check(-1); WFIFOHEAD(char_fd,44); WFIFOW(char_fd,0) = 0x2b0e; WFIFOL(char_fd,2) = acc; safestrncpy((char*)WFIFOP(char_fd,6), character_name, NAME_LENGTH); WFIFOW(char_fd,30) = operation_type; if ( operation_type == 2 ) { WFIFOW(char_fd,32) = year; WFIFOW(char_fd,34) = month; WFIFOW(char_fd,36) = day; WFIFOW(char_fd,38) = hour; WFIFOW(char_fd,40) = minute; WFIFOW(char_fd,42) = second; } WFIFOSET(char_fd,44); return 0; } int chrif_changesex(struct map_session_data *sd) { chrif_check(-1); WFIFOHEAD(char_fd,44); WFIFOW(char_fd,0) = 0x2b0e; WFIFOL(char_fd,2) = sd->status.account_id; safestrncpy((char*)WFIFOP(char_fd,6), sd->status.name, NAME_LENGTH); WFIFOW(char_fd,30) = 5; WFIFOSET(char_fd,44); clif_displaymessage(sd->fd, msg_txt(410)); //"Need disconnection to perform change-sex request..." if (sd->fd) clif_authfail_fd(sd->fd, 15); else map_quit(sd); return 0; } /*========================================== * R 2b0f <accid>.l <name>.24B <type>.w <answer>.w * Processing a reply to chrif_char_ask_name() (request to modify an account). * type of operation: * 1: block, 2: ban, 3: unblock, 4: unban, 5: changesex * type of answer: * 0: login-server request done * 1: player not found * 2: gm level too low * 3: login-server offline *------------------------------------------*/ static void chrif_char_ask_name_answer(int acc, const char* player_name, uint16 type, uint16 answer) { struct map_session_data* sd; char action[25]; char output[256]; sd = map_id2sd(acc); if( acc < 0 || sd == NULL ) { ShowError("chrif_char_ask_name_answer failed - player not online.\n"); return; } if( type > 0 && type <= 5 ) snprintf(action,25,"%s",msg_txt(427+type)); //block|ban|unblock|unban|change the sex of else snprintf(action,25,"???"); switch( answer ) { case 0 : sprintf(output, msg_txt(424), action, NAME_LENGTH, player_name); break; case 1 : sprintf(output, msg_txt(425), NAME_LENGTH, player_name); break; case 2 : sprintf(output, msg_txt(426), action, NAME_LENGTH, player_name); break; case 3 : sprintf(output, msg_txt(427), action, NAME_LENGTH, player_name); break; default: output[0] = '\0'; break; } clif_displaymessage(sd->fd, output); } /*========================================== * Request char server to change sex of char (modified by Yor) *------------------------------------------*/ int chrif_changedsex(int fd) { int acc, sex, i; struct map_session_data *sd; acc = RFIFOL(fd,2); sex = RFIFOL(fd,6); if ( battle_config.etc_log ) ShowNotice("chrif_changedsex %d.\n", acc); sd = map_id2sd(acc); if ( sd ) { //Normally there should not be a char logged on right now! if ( sd->status.sex == sex ) return 0; //Do nothing? Likely safe. sd->status.sex = !sd->status.sex; // reset skill of some job if ((sd->class_&MAPID_UPPERMASK) == MAPID_BARDDANCER) { // remove specifical skills of Bard classes for(i = 315; i <= 322; i++) { if (sd->status.skill[i].id > 0 && sd->status.skill[i].flag == SKILL_FLAG_PERMANENT) { sd->status.skill_point += sd->status.skill[i].lv; sd->status.skill[i].id = 0; sd->status.skill[i].lv = 0; } } // remove specifical skills of Dancer classes for(i = 323; i <= 330; i++) { if (sd->status.skill[i].id > 0 && sd->status.skill[i].flag == SKILL_FLAG_PERMANENT) { sd->status.skill_point += sd->status.skill[i].lv; sd->status.skill[i].id = 0; sd->status.skill[i].lv = 0; } } clif_updatestatus(sd, SP_SKILLPOINT); // change job if necessary if (sd->status.sex) //Changed from Dancer sd->status.class_ -= 1; else //Changed from Bard sd->status.class_ += 1; //sd->class_ needs not be updated as both Dancer/Bard are the same. } // save character sd->login_id1++; // change identify, because if player come back in char within the 5 seconds, he can change its characters // do same modify in login-server for the account, but no in char-server (it ask again login_id1 to login, and don't remember it) clif_displaymessage(sd->fd, msg_txt(411)); //"Your sex has been changed (need disconnection by the server)..." set_eof(sd->fd); // forced to disconnect for the change map_quit(sd); // Remove leftovers (e.g. autotrading) [Paradox924X] } return 0; } /*========================================== * Request Char Server to Divorce Players *------------------------------------------*/ int chrif_divorce(int partner_id1, int partner_id2) { chrif_check(-1); WFIFOHEAD(char_fd,10); WFIFOW(char_fd,0) = 0x2b11; WFIFOL(char_fd,2) = partner_id1; WFIFOL(char_fd,6) = partner_id2; WFIFOSET(char_fd,10); return 0; } /*========================================== * Divorce players * only used if 'partner_id' is offline *------------------------------------------*/ int chrif_divorceack(int char_id, int partner_id) { struct map_session_data* sd; int i; if( !char_id || !partner_id ) return 0; if( ( sd = map_charid2sd(char_id) ) != NULL && sd->status.partner_id == partner_id ) { sd->status.partner_id = 0; for(i = 0; i < MAX_INVENTORY; i++) if (sd->status.inventory[i].nameid == WEDDING_RING_M || sd->status.inventory[i].nameid == WEDDING_RING_F) pc_delitem(sd, i, 1, 0, 0, LOG_TYPE_OTHER); } if( ( sd = map_charid2sd(partner_id) ) != NULL && sd->status.partner_id == char_id ) { sd->status.partner_id = 0; for(i = 0; i < MAX_INVENTORY; i++) if (sd->status.inventory[i].nameid == WEDDING_RING_M || sd->status.inventory[i].nameid == WEDDING_RING_F) pc_delitem(sd, i, 1, 0, 0, LOG_TYPE_OTHER); } return 0; } /*========================================== * Removes Baby from parents *------------------------------------------*/ int chrif_deadopt(int father_id, int mother_id, int child_id) { struct map_session_data* sd; if( father_id && ( sd = map_charid2sd(father_id) ) != NULL && sd->status.child == child_id ) { sd->status.child = 0; sd->status.skill[WE_CALLBABY].id = 0; sd->status.skill[WE_CALLBABY].lv = 0; sd->status.skill[WE_CALLBABY].flag = 0; clif_deleteskill(sd,WE_CALLBABY); } if( mother_id && ( sd = map_charid2sd(mother_id) ) != NULL && sd->status.child == child_id ) { sd->status.child = 0; sd->status.skill[WE_CALLBABY].id = 0; sd->status.skill[WE_CALLBABY].lv = 0; sd->status.skill[WE_CALLBABY].flag = 0; clif_deleteskill(sd,WE_CALLBABY); } return 0; } /*========================================== * Disconnection of a player (account has been banned of has a status, from login-server) by [Yor] *------------------------------------------*/ int chrif_accountban(int fd) { int acc; struct map_session_data *sd; acc = RFIFOL(fd,2); if ( battle_config.etc_log ) ShowNotice("chrif_accountban %d.\n", acc); sd = map_id2sd(acc); if ( acc < 0 || sd == NULL ) { ShowError("chrif_accountban failed - player not online.\n"); return 0; } sd->login_id1++; // change identify, because if player come back in char within the 5 seconds, he can change its characters if (RFIFOB(fd,6) == 0) { // 0: change of statut, 1: ban int ret_status = RFIFOL(fd,7); // status or final date of a banishment if(0<ret_status && ret_status<=9) clif_displaymessage(sd->fd, msg_txt(411+ret_status)); else if(ret_status==100) clif_displaymessage(sd->fd, msg_txt(421)); else clif_displaymessage(sd->fd, msg_txt(420)); //"Your account has not more authorised." } else if (RFIFOB(fd,6) == 1) { // 0: change of statut, 1: ban time_t timestamp; char tmpstr[2048]; timestamp = (time_t)RFIFOL(fd,7); // status or final date of a banishment strcpy(tmpstr, msg_txt(423)); //"Your account has been banished until " strftime(tmpstr + strlen(tmpstr), 24, "%d-%m-%Y %H:%M:%S", localtime(×tamp)); clif_displaymessage(sd->fd, tmpstr); } set_eof(sd->fd); // forced to disconnect for the change map_quit(sd); // Remove leftovers (e.g. autotrading) [Paradox924X] return 0; } //Disconnect the player out of the game, simple packet //packet.w AID.L WHY.B 2+4+1 = 7byte int chrif_disconnectplayer(int fd) { struct map_session_data* sd; int account_id = RFIFOL(fd, 2); sd = map_id2sd(account_id); if( sd == NULL ) { struct auth_node* auth = chrif_search(account_id); if( auth != NULL && chrif_auth_delete(account_id, auth->char_id, ST_LOGIN) ) return 0; return -1; } if (!sd->fd) { //No connection if (sd->state.autotrade) map_quit(sd); //Remove it. //Else we don't remove it because the char should have a timer to remove the player because it force-quit before, //and we don't want them kicking their previous instance before the 10 secs penalty time passes. [Skotlex] return 0; } switch(RFIFOB(fd, 6)) { case 1: clif_authfail_fd(sd->fd, 1); break; //server closed case 2: clif_authfail_fd(sd->fd, 2); break; //someone else logged in case 3: clif_authfail_fd(sd->fd, 4); break; //server overpopulated case 4: clif_authfail_fd(sd->fd, 10); break; //out of available time paid for case 5: clif_authfail_fd(sd->fd, 15); break; //forced to dc by gm } return 0; } /*========================================== * Request/Receive top 10 Fame character list *------------------------------------------*/ int chrif_updatefamelist(struct map_session_data* sd) { char type; chrif_check(-1); switch(sd->class_ & MAPID_UPPERMASK) { case MAPID_BLACKSMITH: type = 1; break; case MAPID_ALCHEMIST: type = 2; break; case MAPID_TAEKWON: type = 3; break; default: return 0; } WFIFOHEAD(char_fd, 11); WFIFOW(char_fd,0) = 0x2b10; WFIFOL(char_fd,2) = sd->status.char_id; WFIFOL(char_fd,6) = sd->status.fame; WFIFOB(char_fd,10) = type; WFIFOSET(char_fd,11); return 0; } int chrif_buildfamelist(void) { chrif_check(-1); WFIFOHEAD(char_fd,2); WFIFOW(char_fd,0) = 0x2b1a; WFIFOSET(char_fd,2); return 0; } int chrif_recvfamelist(int fd) { int num, size; int total = 0, len = 8; memset (smith_fame_list, 0, sizeof(smith_fame_list)); memset (chemist_fame_list, 0, sizeof(chemist_fame_list)); memset (taekwon_fame_list, 0, sizeof(taekwon_fame_list)); size = RFIFOW(fd, 6); //Blacksmith block size for (num = 0; len < size && num < MAX_FAME_LIST; num++) { memcpy(&smith_fame_list[num], RFIFOP(fd,len), sizeof(struct fame_list)); len += sizeof(struct fame_list); } total += num; size = RFIFOW(fd, 4); //Alchemist block size for (num = 0; len < size && num < MAX_FAME_LIST; num++) { memcpy(&chemist_fame_list[num], RFIFOP(fd,len), sizeof(struct fame_list)); len += sizeof(struct fame_list); } total += num; size = RFIFOW(fd, 2); //Total packet length for (num = 0; len < size && num < MAX_FAME_LIST; num++) { memcpy(&taekwon_fame_list[num], RFIFOP(fd,len), sizeof(struct fame_list)); len += sizeof(struct fame_list); } total += num; ShowInfo("Received Fame List of '"CL_WHITE"%d"CL_RESET"' characters.\n", total); return 0; } /// fame ranking update confirmation /// R 2b22 <table>.B <index>.B <value>.L int chrif_updatefamelist_ack(int fd) { struct fame_list* list; uint8 index; switch (RFIFOB(fd,2)) { case 1: list = smith_fame_list; break; case 2: list = chemist_fame_list; break; case 3: list = taekwon_fame_list; break; default: return 0; } index = RFIFOB(fd, 3); if (index >= MAX_FAME_LIST) return 0; list[index].fame = RFIFOL(fd,4); return 1; } int chrif_save_scdata(struct map_session_data *sd) { //parses the sc_data of the player and sends it to the char-server for saving. [Skotlex] #ifdef ENABLE_SC_SAVING int i, count=0; unsigned int tick; struct status_change_data data; struct status_change *sc = &sd->sc; const struct TimerData *timer; chrif_check(-1); tick = gettick(); WFIFOHEAD(char_fd, 14 + SC_MAX*sizeof(struct status_change_data)); WFIFOW(char_fd,0) = 0x2b1c; WFIFOL(char_fd,4) = sd->status.account_id; WFIFOL(char_fd,8) = sd->status.char_id; for (i = 0; i < SC_MAX; i++) { if (!sc->data[i]) continue; if (sc->data[i]->timer != INVALID_TIMER) { timer = get_timer(sc->data[i]->timer); if (timer == NULL || timer->func != status_change_timer || DIFF_TICK(timer->tick,tick) < 0) continue; data.tick = DIFF_TICK(timer->tick,tick); //Duration that is left before ending. } else data.tick = -1; //Infinite duration data.type = i; data.val1 = sc->data[i]->val1; data.val2 = sc->data[i]->val2; data.val3 = sc->data[i]->val3; data.val4 = sc->data[i]->val4; memcpy(WFIFOP(char_fd,14 +count*sizeof(struct status_change_data)), &data, sizeof(struct status_change_data)); count++; } if (count == 0) return 0; //Nothing to save. WFIFOW(char_fd,12) = count; WFIFOW(char_fd,2) = 14 +count*sizeof(struct status_change_data); //Total packet size WFIFOSET(char_fd,WFIFOW(char_fd,2)); #endif return 0; } //Retrieve and load sc_data for a player. [Skotlex] int chrif_load_scdata(int fd) { #ifdef ENABLE_SC_SAVING struct map_session_data *sd; struct status_change_data *data; int aid, cid, i, count; aid = RFIFOL(fd,4); //Player Account ID cid = RFIFOL(fd,8); //Player Char ID sd = map_id2sd(aid); if ( !sd ) { ShowError("chrif_load_scdata: Player of AID %d not found!\n", aid); return -1; } if ( sd->status.char_id != cid ) { ShowError("chrif_load_scdata: Receiving data for account %d, char id does not matches (%d != %d)!\n", aid, sd->status.char_id, cid); return -1; } count = RFIFOW(fd,12); //sc_count for (i = 0; i < count; i++) { data = (struct status_change_data*)RFIFOP(fd,14 + i*sizeof(struct status_change_data)); status_change_start(&sd->bl, (sc_type)data->type, 10000, data->val1, data->val2, data->val3, data->val4, data->tick, 15); } #endif return 0; } /*========================================== * Send rates and motd to char server [Wizputer] * S 2b16 <base rate>.L <job rate>.L <drop rate>.L *------------------------------------------*/ int chrif_ragsrvinfo(int base_rate, int job_rate, int drop_rate) { chrif_check(-1); WFIFOHEAD(char_fd,14); WFIFOW(char_fd,0) = 0x2b16; WFIFOL(char_fd,2) = base_rate; WFIFOL(char_fd,6) = job_rate; WFIFOL(char_fd,10) = drop_rate; WFIFOSET(char_fd,14); return 0; } /*========================================= * Tell char-server charcter disconnected [Wizputer] *-----------------------------------------*/ int chrif_char_offline(struct map_session_data *sd) { chrif_check(-1); WFIFOHEAD(char_fd,10); WFIFOW(char_fd,0) = 0x2b17; WFIFOL(char_fd,2) = sd->status.char_id; WFIFOL(char_fd,6) = sd->status.account_id; WFIFOSET(char_fd,10); return 0; } int chrif_char_offline_nsd(int account_id, int char_id) { chrif_check(-1); WFIFOHEAD(char_fd,10); WFIFOW(char_fd,0) = 0x2b17; WFIFOL(char_fd,2) = char_id; WFIFOL(char_fd,6) = account_id; WFIFOSET(char_fd,10); return 0; } /*========================================= * Tell char-server to reset all chars offline [Wizputer] *-----------------------------------------*/ int chrif_flush_fifo(void) { chrif_check(-1); set_nonblocking(char_fd, 0); flush_fifos(); set_nonblocking(char_fd, 1); return 0; } /*========================================= * Tell char-server to reset all chars offline [Wizputer] *-----------------------------------------*/ int chrif_char_reset_offline(void) { chrif_check(-1); WFIFOHEAD(char_fd,2); WFIFOW(char_fd,0) = 0x2b18; WFIFOSET(char_fd,2); return 0; } /*========================================= * Tell char-server charcter is online [Wizputer] *-----------------------------------------*/ int chrif_char_online(struct map_session_data *sd) { chrif_check(-1); WFIFOHEAD(char_fd,10); WFIFOW(char_fd,0) = 0x2b19; WFIFOL(char_fd,2) = sd->status.char_id; WFIFOL(char_fd,6) = sd->status.account_id; WFIFOSET(char_fd,10); return 0; } /// Called when the connection to Char Server is disconnected. void chrif_on_disconnect(void) { if( chrif_connected != 1 ) ShowWarning("Connection to Char Server lost.\n\n"); chrif_connected = 0; other_mapserver_count = 0; //Reset counter. We receive ALL maps from all map-servers on reconnect. map_eraseallipport(); //Attempt to reconnect in a second. [Skotlex] add_timer(gettick() + 1000, check_connect_char_server, 0, 0); } void chrif_update_ip(int fd) { uint32 new_ip; WFIFOHEAD(fd,6); new_ip = host2ip(char_ip_str); if (new_ip && new_ip != char_ip) char_ip = new_ip; //Update char_ip new_ip = clif_refresh_ip(); if (!new_ip) return; //No change WFIFOW(fd,0) = 0x2736; WFIFOL(fd,2) = htonl(new_ip); WFIFOSET(fd,6); } // pings the charserver void chrif_keepalive(int fd) { WFIFOHEAD(fd,2); WFIFOW(fd,0) = 0x2b23; WFIFOSET(fd,2); } void chrif_keepalive_ack(int fd) { session[fd]->flag.ping = 0;/* reset ping state, we received a packet */ } /*========================================== * *------------------------------------------*/ int chrif_parse(int fd) { int packet_len, cmd; // only process data from the char-server if ( fd != char_fd ) { ShowDebug("chrif_parse: Disconnecting invalid session #%d (is not the char-server)\n", fd); do_close(fd); return 0; } if ( session[fd]->flag.eof ) { do_close(fd); char_fd = -1; chrif_on_disconnect(); return 0; } else if ( session[fd]->flag.ping ) {/* we've reached stall time */ if( DIFF_TICK(last_tick, session[fd]->rdata_tick) > (stall_time * 2) ) {/* we can't wait any longer */ set_eof(fd); return 0; } else if( session[fd]->flag.ping != 2 ) { /* we haven't sent ping out yet */ chrif_keepalive(fd); session[fd]->flag.ping = 2; } } while ( RFIFOREST(fd) >= 2 ) { cmd = RFIFOW(fd,0); if (cmd < 0x2af8 || cmd >= 0x2af8 + ARRAYLENGTH(packet_len_table) || packet_len_table[cmd-0x2af8] == 0) { int r = intif_parse(fd); // Passed on to the intif if (r == 1) continue; // Treated in intif if (r == 2) return 0; // Didn't have enough data (len==-1) ShowWarning("chrif_parse: session #%d, intif_parse failed (unrecognized command 0x%.4x).\n", fd, cmd); set_eof(fd); return 0; } if ( ( packet_len = packet_len_table[cmd-0x2af8] ) == -1) { // dynamic-length packet, second WORD holds the length if (RFIFOREST(fd) < 4) return 0; packet_len = RFIFOW(fd,2); } if ((int)RFIFOREST(fd) < packet_len) return 0; //ShowDebug("Received packet 0x%4x (%d bytes) from char-server (connection %d)\n", RFIFOW(fd,0), packet_len, fd); switch(cmd) { case 0x2af9: chrif_connectack(fd); break; case 0x2afb: chrif_sendmapack(fd); break; case 0x2afd: chrif_authok(fd); break; case 0x2b00: map_setusers(RFIFOL(fd,2)); chrif_keepalive(fd); break; case 0x2b03: clif_charselectok(RFIFOL(fd,2), RFIFOB(fd,6)); break; case 0x2b04: chrif_recvmap(fd); break; case 0x2b06: chrif_changemapserverack(RFIFOL(fd,2), RFIFOL(fd,6), RFIFOL(fd,10), RFIFOL(fd,14), RFIFOW(fd,18), RFIFOW(fd,20), RFIFOW(fd,22), RFIFOL(fd,24), RFIFOW(fd,28)); break; case 0x2b09: map_addnickdb(RFIFOL(fd,2), (char*)RFIFOP(fd,6)); break; case 0x2b0d: chrif_changedsex(fd); break; case 0x2b0f: chrif_char_ask_name_answer(RFIFOL(fd,2), (char*)RFIFOP(fd,6), RFIFOW(fd,30), RFIFOW(fd,32)); break; case 0x2b12: chrif_divorceack(RFIFOL(fd,2), RFIFOL(fd,6)); break; case 0x2b14: chrif_accountban(fd); break; case 0x2b1b: chrif_recvfamelist(fd); break; case 0x2b1d: chrif_load_scdata(fd); break; case 0x2b1e: chrif_update_ip(fd); break; case 0x2b1f: chrif_disconnectplayer(fd); break; case 0x2b20: chrif_removemap(fd); break; case 0x2b21: chrif_save_ack(fd); break; case 0x2b22: chrif_updatefamelist_ack(fd); break; case 0x2b24: chrif_keepalive_ack(fd); break; case 0x2b25: chrif_deadopt(RFIFOL(fd,2), RFIFOL(fd,6), RFIFOL(fd,10)); break; case 0x2b27: chrif_authfail(fd); break; default: ShowError("chrif_parse : unknown packet (session #%d): 0x%x. Disconnecting.\n", fd, cmd); set_eof(fd); return 0; } if ( fd == char_fd ) //There's the slight chance we lost the connection during parse, in which case this would segfault if not checked [Skotlex] RFIFOSKIP(fd, packet_len); } return 0; } // unused int send_usercount_tochar(int tid, unsigned int tick, int id, intptr_t data) { chrif_check(-1); WFIFOHEAD(char_fd,4); WFIFOW(char_fd,0) = 0x2afe; WFIFOW(char_fd,2) = map_usercount(); WFIFOSET(char_fd,4); return 0; } /*========================================== * timerFunction * Send to char the number of client connected to map *------------------------------------------*/ int send_users_tochar(void) { int users = 0, i = 0; struct map_session_data* sd; struct s_mapiterator* iter; chrif_check(-1); users = map_usercount(); WFIFOHEAD(char_fd, 6+8*users); WFIFOW(char_fd,0) = 0x2aff; iter = mapit_getallusers(); for( sd = (TBL_PC*)mapit_first(iter); mapit_exists(iter); sd = (TBL_PC*)mapit_next(iter) ) { WFIFOL(char_fd,6+8*i) = sd->status.account_id; WFIFOL(char_fd,6+8*i+4) = sd->status.char_id; i++; } mapit_free(iter); WFIFOW(char_fd,2) = 6 + 8*users; WFIFOW(char_fd,4) = users; WFIFOSET(char_fd, 6+8*users); return 0; } /*========================================== * timerFunction * Chk the connection to char server, (if it down) *------------------------------------------*/ static int check_connect_char_server(int tid, unsigned int tick, int id, intptr_t data) { static int displayed = 0; if ( char_fd <= 0 || session[char_fd] == NULL ) { if ( !displayed ) { ShowStatus("Attempting to connect to Char Server. Please wait.\n"); displayed = 1; } chrif_state = 0; char_fd = make_connection(char_ip, char_port,false); if (char_fd == -1)//Attempt to connect later. [Skotlex] return 0; session[char_fd]->func_parse = chrif_parse; session[char_fd]->flag.server = 1; realloc_fifo(char_fd, FIFOSIZE_SERVERLINK, FIFOSIZE_SERVERLINK); chrif_connect(char_fd); chrif_connected = (chrif_state == 2); srvinfo = 0; } else { if (srvinfo == 0) { chrif_ragsrvinfo(battle_config.base_exp_rate, battle_config.job_exp_rate, battle_config.item_rate_common); srvinfo = 1; } } if ( chrif_isconnected() ) displayed = 0; return 0; } /*========================================== * Asks char server to remove friend_id from the friend list of char_id *------------------------------------------*/ int chrif_removefriend(int char_id, int friend_id) { chrif_check(-1); WFIFOHEAD(char_fd,10); WFIFOW(char_fd,0) = 0x2b07; WFIFOL(char_fd,2) = char_id; WFIFOL(char_fd,6) = friend_id; WFIFOSET(char_fd,10); return 0; } void chrif_send_report(char* buf, int len) { #ifndef STATS_OPT_OUT WFIFOHEAD(char_fd,len + 2); WFIFOW(char_fd,0) = 0x3008; memcpy(WFIFOP(char_fd,2), buf, len); WFIFOSET(char_fd,len + 2); flush_fifo(char_fd); /* ensure it's sent now. */ #endif } /** * @see DBApply */ int auth_db_final(DBKey key, DBData *data, va_list ap) { struct auth_node *node = db_data2ptr(data); if (node->char_dat) aFree(node->char_dat); if (node->sd) aFree(node->sd); ers_free(auth_db_ers, node); return 0; } /*========================================== * Destructor *------------------------------------------*/ int do_final_chrif(void) { if( char_fd != -1 ) { do_close(char_fd); char_fd = -1; } auth_db->destroy(auth_db, auth_db_final); ers_destroy(auth_db_ers); return 0; } /*========================================== * *------------------------------------------*/ int do_init_chrif(void) { auth_db = idb_alloc(DB_OPT_BASE); auth_db_ers = ers_new(sizeof(struct auth_node),"chrif.c::auth_db_ers",ERS_OPT_NONE); add_timer_func_list(check_connect_char_server, "check_connect_char_server"); add_timer_func_list(auth_db_cleanup, "auth_db_cleanup"); // establish map-char connection if not present add_timer_interval(gettick() + 1000, check_connect_char_server, 0, 0, 10 * 1000); // wipe stale data for timed-out client connection requests add_timer_interval(gettick() + 1000, auth_db_cleanup, 0, 0, 30 * 1000); // send the user count every 10 seconds, to hide the charserver's online counting problem add_timer_interval(gettick() + 1000, send_usercount_tochar, 0, 0, UPDATE_INTERVAL); return 0; }