query_status_t deal_with_tm_packet( struct qserver *server, char *rawpkt, int pktlen ) { char *s; char *pkt = rawpkt; char *key = NULL, *value = NULL, *tmpp = NULL; char fullname[256]; struct player *player = NULL; int pkt_max = server->saved_data.pkt_max; unsigned total_len, expected_len; int method_response = 1; debug( 2, "processing..." ); s = rawpkt; // We may get the setup handle and the protocol version in one packet we may not // So we continue to parse if we see the handle if ( 4 <= pktlen && 0 == memcmp( pkt, "\x0b\x00\x00\x00", 4 ) ) { // setup handle identifier // greater 2^31 = XML-RPC, less = callback server->challenge = 0x80000001; if ( 4 == pktlen ) { return 0; } pktlen -= 4; pkt += 4; } if ( 11 <= pktlen && 1 == sscanf( pkt, "GBXRemote %d", &server->protocol_version ) ) { // Got protocol version send request send_tm_request_packet( server ); return 0; } if ( 8 <= pktlen && 0 == memcmp( pkt+4, &server->challenge, 4 ) ) { // first 4 bytes = the length // Note: We use pkt_id to store the length of the expected packet // this could cause loss but very unlikely unsigned long len; memcpy( &len, rawpkt, 4 ); // second 4 bytes = handle identifier we sent in the request if ( 8 == pktlen ) { // split packet // we have at least one more packet coming if ( ! add_packet( server, len, 0, 2, pktlen, rawpkt, 1 ) ) { // fatal error e.g. out of memory return -1; } return 0; } else { // ensure the length is stored server->saved_data.pkt_id = (int)len; s += 8; } } total_len = combined_length( server, server->saved_data.pkt_id ); expected_len = server->saved_data.pkt_id; debug( 2, "total: %d, expected: %d\n", total_len, expected_len ); if ( total_len < expected_len + 8 ) { // we dont have a complete response add the packet int last, new_max; if ( total_len + pktlen >= expected_len + 8 ) { last = 1; new_max = pkt_max; } else { last = 0; new_max = pkt_max + 1; } if ( ! add_packet( server, server->saved_data.pkt_id, pkt_max - 1, new_max, pktlen, rawpkt, 1 ) ) { // fatal error e.g. out of memory return -1; } if ( last ) { // we are the last packet run combine to call us back return combine_packets( server ); } return 0; } server->n_servers++; if ( server->server_name == NULL) { server->ping_total += time_delta( &packet_recv_time, &server->packet_time1 ); } else { gettimeofday( &server->packet_time1, NULL); } // Terminate the packet data pkt = (char*)malloc( pktlen + 1 ); if ( NULL == pkt ) { debug( 0, "Failed to malloc memory for packet terminator\n" ); return MEM_ERROR; } memcpy( pkt, rawpkt, pktlen ); pkt[pktlen] = '\0'; //fprintf( stderr, "S=%s\n", s ); s = strtok( pkt + 8, "\015\012" ); while ( NULL != s ) { //fprintf( stderr, "S=%s\n", s ); if ( 0 == strncmp( s, "<member><name>", 14 ) ) { key = s + 14; tmpp = strstr( key, "</name>" ); if ( NULL != tmpp ) { *tmpp = '\0'; } s = strtok( NULL, "\015\012" ); value = NULL; continue; } else if ( NULL != key && 0 == strncmp( s, "<value>", 7 ) ) { // value s += 7; if ( 0 == strncmp( s, "<string>", 8 ) ) { // String value = s+8; tmpp = strstr( s, "</string>" ); } else if ( 0 == strncmp( s, "<i4>", 4 ) ) { // Int value = s+4; tmpp = strstr( s, "</i4>" ); } else if ( 0 == strncmp( s, "<boolean>", 9 ) ) { // Boolean value = s+9; tmpp = strstr( s, "</boolean>" ); } else if ( 0 == strncmp( s, "<double>", 8 ) ) { // Double value = s+8; tmpp = strstr( s, "</double>" ); } // also have struct and array but not interested in those if ( NULL != tmpp ) { *tmpp = '\0'; } if ( NULL != value ) { debug( 4, "%s = %s\n", key, value ); } } else if ( 0 == strncmp( s, "</struct>", 9 ) && 3 > method_response ) { // end of method response method_response++; } if ( NULL != value && NULL != key ) { switch( method_response ) { case 1: // GetServerOptions response if ( 0 == strcmp( "Name", key ) ) { server->server_name = strdup( value ); } else if ( 0 == strcmp( "CurrentMaxPlayers", key ) ) { server->max_players = atoi( value ); } else { sprintf( fullname, "server.%s", key ); add_rule( server, fullname, value, NO_FLAGS); } break; case 2: // GetCurrentChallengeInfo response if ( 0 == strcmp( "Name", key ) ) { server->map_name = strdup( value ); } else { sprintf( fullname, "challenge.%s", key ); add_rule( server, fullname, value, NO_FLAGS); } break; case 3: // GetPlayerList response // Player info if ( 0 == strcmp( "Login", key ) ) { player = add_player( server, server->n_player_info ); server->num_players++; } else if ( NULL != player ) { if ( 0 == strcmp( "NickName", key ) ) { player->name = strdup( value ); } else if ( 0 == strcmp( "PlayerId", key ) ) { //player->number = atoi( value ); } else if ( 0 == strcmp( "TeamId", key ) ) { player->team = atoi( value ); } else if ( 0 == strcmp( "IsSpectator", key ) ) { player->flags = player->flags & 1; } else if ( 0 == strcmp( "IsInOfficialMode", key ) ) { player->flags = player->flags & 2; } else if ( 0 == strcmp( "LadderRanking", key ) ) { player->score = atoi( value ); } } break; } value = NULL; } s = strtok( NULL, "\015\012" ); } free( pkt ); if ( 0 == strncmp( rawpkt + pktlen - 19, "</methodResponse>", 17 ) ) { // last packet seen return DONE_FORCE; } return INPROGRESS; }
query_status_t deal_with_crysis_packet(struct qserver *server, char *rawpkt, int pktlen) { char *s, *val, *line; query_status_t state = INPROGRESS; debug(2, "processing..."); if (!server->combined) { state = valid_crysis_response(server, rawpkt, pktlen); server->retry1 = n_retries; if (0 == server->n_requests) { server->ping_total = time_delta(&packet_recv_time, &server->packet_time1); server->n_requests++; } switch (state) { case INPROGRESS: { // response fragment recieved int pkt_id; int pkt_max; // We're expecting more to come debug(5, "fragment recieved..."); pkt_id = packet_count(server); pkt_max = pkt_id++; if (!add_packet(server, 0, pkt_id, pkt_max, pktlen, rawpkt, 1)) { // fatal error e.g. out of memory return (MEM_ERROR); } // combine_packets will call us recursively return (combine_packets(server)); } case DONE_FORCE: break; // single packet response fall through default: return (state); } } if (DONE_FORCE != state) { state = valid_crysis_response(server, rawpkt, pktlen); switch (state) { case DONE_FORCE: break; // actually process default: return (state); } } debug(3, "packet: challenge = %ld", server->challenge); s = NULL; switch (server->challenge) { case 1: s = crysis_response(server, rawpkt, pktlen); if (NULL != s) { server->challenge_string = s; return (send_crysis_request_packet(server)); } return (REQ_ERROR); case 2: s = crysis_response(server, rawpkt, pktlen); if (NULL == s) { return (REQ_ERROR); } if (0 != strncmp(s, "authorized", 10)) { free(s); return (REQ_ERROR); } free(s); return (send_crysis_request_packet(server)); case 3: s = crysis_response(server, rawpkt, pktlen); if (NULL == s) { return (REQ_ERROR); } } // Correct ping // Not quite right but gives a good estimate server->ping_total = (server->ping_total * server->n_requests) / 2; debug(3, "processing response..."); s = decode_crysis_val(s); line = strtok(s, "\012"); // NOTE: id=XXX and msg=XXX will be processed by the mod following the one they where the response of while (NULL != line) { debug(4, "LINE: %s\n", line); val = strstr(line, ":"); if (NULL != val) { *val = '\0'; val += 2; debug(4, "var: %s, val: %s", line, val); if (0 == strcmp("name", line)) { server->server_name = strdup(val); } else if (0 == strcmp("level", line)) { server->map_name = strdup(val); } else if (0 == strcmp("players", line)) { if (2 == sscanf(val, "%d/%d", &server->num_players, &server->max_players)) { } } else if ( (0 == strcmp("version", line)) || (0 == strcmp("gamerules", line)) || (0 == strcmp("time remaining", line)) ) { add_rule(server, line, val, NO_FLAGS); } } line = strtok(NULL, "\012"); } gettimeofday(&server->packet_time1, NULL); return (DONE_FORCE); }
query_status_t deal_with_ts3_packet(struct qserver *server, char *rawpkt, int pktlen) { char *s, *player_name = "unknown"; int valid_response = 0, mode = 0, all_servers = 0; char last_char; unsigned short port = 0, down = 0, auth_seen = 0; debug(2, "processing..."); if (0 == pktlen) { // Invalid password return (REQ_ERROR); } last_char = rawpkt[pktlen - 1]; rawpkt[pktlen - 1] = '\0'; s = rawpkt; all_servers = all_ts3_servers(server); debug(3, "packet: combined = %d, challenge = %ld, n_servers = %d", server->combined, server->challenge, server->n_servers); if (!server->combined) { server->retry1 = n_retries; if (0 == server->n_requests) { server->ping_total = time_delta(&packet_recv_time, &server->packet_time1); server->n_requests++; } if (server->n_servers >= server->challenge) { // response fragment recieved int pkt_id; int pkt_max; // We're expecting more to come debug(5, "fragment recieved..."); pkt_id = packet_count(server); pkt_max = pkt_id + 1; rawpkt[pktlen - 1] = last_char; // restore the last character if (!add_packet(server, 0, pkt_id, pkt_max, pktlen, rawpkt, 1)) { // fatal error e.g. out of memory return (MEM_ERROR); } // combine_packets will call us recursively return (combine_packets(server)); } } else { valid_response = valid_ts3_response(server, rawpkt + server->master_pkt_len, pktlen - server->master_pkt_len); debug(2, "combined packet: valid_response: %d, challenge: %ld, n_servers: %d, offset: %d", valid_response, server->challenge, server->n_servers, server->master_pkt_len); if (0 > valid_response) { // Error occured return (valid_response); } server->challenge += valid_response; if (valid_response) { // Got a valid response, send the next request int ret = send_ts3_request_packet(server); if (0 != ret) { // error sending packet debug(4, "Request failed: %d", ret); return (ret); } } if (server->n_servers > server->challenge) { // recursive call which is still incomplete return (INPROGRESS); } } // Correct ping // Not quite right but gives a good estimate server->ping_total = (server->ping_total * server->n_requests) / 2; debug(3, "processing response..."); s = strtok(rawpkt, "\012\015 |"); // NOTE: id=XXX and msg=XXX will be processed by the mod following the one they where the response of while (NULL != s) { debug(4, "LINE: %d, %s\n", mode, s); switch (mode) { case 0: // prompt, use or serverlist response if (0 == strcmp("TS3", s)) { // nothing to do unless in all servers mode if (1 == all_servers) { mode++; } } else if (0 == strncmp("error", s, 5)) { // end of use response mode++; } break; case 1: // serverinfo or serverlist response including condition authentication if ((0 == auth_seen) && (0 != strlen(get_param_value(server, "password", ""))) && (0 == strncmp("error", s, 5))) { // end of auth response auth_seen = 1; } else if (0 == strncmp("error", s, 5)) { // end of serverinfo response mode++; } else { // Server Rule char *key = s; char *value = strchr(key, '='); if (NULL != value) { *value = '\0'; value++; debug(6, "Rule: %s = %s\n", key, value); if (0 == strcmp("virtualserver_name", key)) { if (1 == all_servers) { struct qserver *new_server = add_qserver_byaddr(ntohl(server->ipaddr), port, server->type, NULL); if (NULL != new_server) { if (down) { // Status indicates this server is actually offline new_server->server_name = DOWN; } else { new_server->max_players = server->max_players; new_server->num_players = server->num_players; new_server->server_name = strdup(decode_ts3_val(value)); new_server->map_name = strdup("N/A"); new_server->ping_total = server->ping_total; new_server->n_requests = server->n_requests; } cleanup_qserver(new_server, FORCE); } down = 0; } else { server->server_name = strdup(decode_ts3_val(value)); } } else if (0 == strcmp("virtualserver_port", key)) { port = atoi(value); change_server_port(server, port, 0); add_rule(server, key, value, NO_FLAGS); } else if (0 == strcmp("virtualserver_maxclients", key)) { server->max_players = atoi(value); } else if (0 == strcmp("virtualserver_clientsonline", key)) { server->num_players = atoi(value); } else if (0 == strcmp("virtualserver_queryclientsonline", key)) { // clientsonline includes queryclientsonline so remove these from our count server->num_players -= atoi(value); } else if ((0 == strcmp("virtualserver_status", key)) && (0 != strcmp("online", value))) { // Server is actually offline to client so display as down down = 1; if (1 != all_servers) { server->server_name = DOWN; //server->saved_data.pkt_index = 0; return (DONE_FORCE); } } else if ((0 == strcmp("id", key)) || (0 == strcmp("msg", key))) { // Ignore details from the response code } else if (1 != all_servers) { add_rule(server, key, value, NO_FLAGS); } } } break; case 2: // clientlist response if (0 == strncmp("error", s, 5)) { // end of serverinfo response mode++; } else { // Client char *key = s; char *value = strchr(key, '='); if (NULL != value) { *value = '\0'; value++; debug(6, "Player: %s = %s\n", key, value); if (0 == strcmp("client_nickname", key)) { player_name = value; } else if (0 == strcmp("clid", key)) { } else if ((0 == strcmp("client_type", key)) && (0 == strcmp("0", value))) { struct player *player = add_player(server, server->n_player_info); if (NULL != player) { player->name = strdup(decode_ts3_val(player_name)); } } else if ((0 == strcmp("id", key)) || (0 == strcmp("msg", key))) { // Ignore details from the response code } } } break; } s = strtok(NULL, "\012\015 |"); } gettimeofday(&server->packet_time1, NULL); server->map_name = strdup("N/A"); return (DONE_FORCE); }
query_status_t deal_with_dirtybomb_packet(struct qserver *server, char *rawpkt, int pktlen) { unsigned char *s, *l, pkt_id, pkt_max; debug(2, "processing..."); if (8 > pktlen) { // not valid response malformed_packet(server, "packet too small"); return PKT_ERROR; } if (rawpkt[4] != 0x01) { // not a known response malformed_packet(server, "unknown packet type 0x%02hhx", rawpkt[4]); return PKT_ERROR; } // Response ID - long // Response Type - byte // Current Packet Number - byte pkt_id = rawpkt[5]; // Last Packet Number - byte pkt_max = rawpkt[6]; // Payload Blob - msgpack map s = (unsigned char*)rawpkt + 7; if (!server->combined) { int pkt_cnt = packet_count(server); server->retry1 = n_retries; if (0 == server->n_requests) { server->ping_total = time_delta( &packet_recv_time, &server->packet_time1 ); server->n_requests++; } if (pkt_cnt < pkt_max) { // We're expecting more to come debug( 5, "fragment recieved..." ); if (!add_packet(server, 0, pkt_id, pkt_max, pktlen, rawpkt, 1)) { // fatal error e.g. out of memory return MEM_ERROR; } // combine_packets will call us recursively return combine_packets(server); } } // Correct ping // Not quite right but gives a good estimate server->ping_total = (server->ping_total * server->n_requests) / 2; debug(3, "processing response..."); gettimeofday(&server->packet_time1, NULL); l = (unsigned char *)rawpkt + pktlen - 1; if (!unpack_msgpack(server, s, l)) { return PKT_ERROR; } return DONE_FORCE; }
query_status_t deal_with_fl_packet(struct qserver *server, char *rawpkt, int pktlen) { struct fl_status* status = (struct fl_status*)server->master_query_tag; char* pkt = rawpkt; char buf[16]; char* str; unsigned cnt; unsigned short tmp_short; if(server->server_name == NULL) { server->ping_total += time_delta( &packet_recv_time, &server->packet_time1); server->n_requests++; } if(pktlen < 5) goto out_too_short; if( 0 == memcmp(pkt, "\xFF\xFF\xFF\xFE", 4) ) { // fragmented packet unsigned char pkt_index, pkt_max; unsigned int pkt_id; SavedData *sdata; if(pktlen < 9) goto out_too_short; // format: // int Header // int RequestId // byte PacketNumber // byte NumPackets // Short SizeOfPacketSplits // Header pkt += 4; // RequestId pkt_id = ntohl( *(long *)pkt ); debug( 3, "RequestID: %d", pkt_id ); pkt += 4; // The next two bytes are: // 1. the max packets sent ( byte ) // 2. the index of this packet starting from 0 ( byte ) // 3. Size of the split ( short ) if(pktlen < 10) goto out_too_short; // PacketNumber pkt_index = ((unsigned char)*pkt); // NumPackates pkt_max = ((unsigned char)*(pkt+1)); // SizeOfPacketSplits debug( 3, "packetid[2]: 0x%hhx => idx: %hhu, max: %hhu", *pkt, pkt_index, pkt_max ); pkt+=4; pktlen -= 12; // pkt_max is the total number of packets expected // pkt_index is a bit mask of the packets received. if ( server->saved_data.data == NULL ) { sdata = &server->saved_data; } else { sdata = (SavedData*) calloc( 1, sizeof(SavedData)); sdata->next = server->saved_data.next; server->saved_data.next = sdata; } sdata->pkt_index = pkt_index; sdata->pkt_max = pkt_max; sdata->pkt_id = pkt_id; sdata->datalen = pktlen; sdata->data= (char*)malloc( pktlen ); if ( NULL == sdata->data ) { malformed_packet(server, "Out of memory"); return MEM_ERROR; } memcpy( sdata->data, pkt, sdata->datalen ); // combine_packets will call us recursively return combine_packets( server ); } else if ( 0 != memcmp(pkt, "\xFF\xFF\xFF\xFF", 4) ) { malformed_packet(server, "invalid packet header"); return PKT_ERROR; } pkt += 4; pktlen -= 4; pktlen -= 1; debug( 2, "FL type = 0x%x", *pkt ); switch(*pkt++) { case FL_CHALLENGERESPONSE: if(pktlen < 4) goto out_too_short; memcpy(&status->challenge, pkt, 4); // do not count challenge as retry if(!status->have_challenge && server->retry1 != n_retries) { ++server->retry1; if(server->n_retries) { --server->n_retries; } } status->have_challenge = 1; debug(3, "challenge %x", status->challenge); break; case FL_INFORESPONSE: if(pktlen < 1) goto out_too_short; status->type = *pkt; if ( *pkt > 1 && ( get_server_rules || get_player_info ) ) { server->next_rule = ""; // trigger calling send_fl_rule_request_packet } snprintf(buf, sizeof(buf), "%hhX", *pkt); add_rule(server, "protocol", buf, 0); pktlen--; pkt++; // ServerName str = memchr(pkt, '\0', pktlen); if(!str) goto out_too_short; server->server_name = strdup(pkt); pktlen -= str-pkt+1; pkt += str-pkt+1; // MapName str = memchr(pkt, '\0', pktlen); if(!str) goto out_too_short; server->map_name = strdup(pkt); pktlen -= str-pkt+1; pkt += str-pkt+1; // ModName str = memchr(pkt, '\0', pktlen); if(!str) goto out_too_short; server->game = strdup(pkt); add_rule(server, "modname", pkt, 0); pktlen -= str-pkt+1; pkt += str-pkt+1; // GameMode str = memchr(pkt, '\0', pktlen); if(!str) goto out_too_short; add_rule(server, "gamemode", pkt, 0); pktlen -= str-pkt+1; pkt += str-pkt+1; // GameDescription str = memchr(pkt, '\0', pktlen); if(!str) goto out_too_short; add_rule(server, "gamedescription", pkt, 0); pktlen -= str-pkt+1; pkt += str-pkt+1; // GameVersion str = memchr(pkt, '\0', pktlen); if(!str) goto out_too_short; add_rule(server, "gameversion", pkt, 0); pktlen -= str-pkt+1; pkt += str-pkt+1; if( pktlen < 13 ) { goto out_too_short; } // GamePort tmp_short = ((unsigned short)pkt[0] <<8 ) | ((unsigned short)pkt[1]); change_server_port( server, tmp_short, 0 ); pkt += 2; // Num Players server->num_players = (unsigned char)*pkt++; // Max Players server->max_players = (unsigned char)*pkt++; // Dedicated add_rule(server, "dedicated", ( 'd' == *pkt++) ? "1" : "0", 0); // OS switch( *pkt ) { case 'l': add_rule(server, "sv_os", "linux", 0); break; case 'w': add_rule(server, "sv_os", "windows", 0); break; default: buf[0] = *pkt; buf[1] = '\0'; add_rule(server, "sv_os", buf, 0); break; } pkt++; // Passworded add_rule(server, "passworded", ( *pkt++ ) ? "1" : "0" , 0); // Anticheat add_rule(server, "passworded", ( *pkt++ ) ? "1" : "0" , 0); // FrameTime sprintf( buf, "%hhu", *pkt++ ); add_rule(server, "frametime", buf , 0); // Round sprintf( buf, "%hhu", *pkt++ ); add_rule(server, "round", buf , 0); // RoundMax sprintf( buf, "%hhu", *pkt++ ); add_rule(server, "roundmax", buf , 0); // RoundSeconds tmp_short = ((unsigned short)pkt[0] <<8 ) | ((unsigned short)pkt[1]); sprintf( buf, "%hu", tmp_short ); add_rule(server, "roundseconds", buf , 0); pkt += 2; status->have_info = 1; server->retry1 = n_retries; server->next_player_info = server->num_players; break; case FL_RULESRESPONSE: if(pktlen < 2) goto out_too_short; cnt = ((unsigned char)pkt[0] << 8 ) + ((unsigned char)pkt[1]); pktlen -= 2; pkt += 2; debug(3, "num_rules: %d", cnt); for(;cnt && pktlen > 0; --cnt) { char* key, *value; str = memchr(pkt, '\0', pktlen); if(!str) break; key = pkt; pktlen -= str-pkt+1; pkt += str-pkt+1; str = memchr(pkt, '\0', pktlen); if(!str) break; value = pkt; pktlen -= str-pkt+1; pkt += str-pkt+1; add_rule(server, key, value, NO_FLAGS); } if(cnt) { malformed_packet(server, "packet contains too few rules, missing %d", cnt); server->missing_rules = 1; } if(pktlen) malformed_packet(server, "garbage at end of rules, %d bytes left", pktlen); status->have_rules = 1; server->retry1 = n_retries; break; case FL_PLAYERRESPONSE: if(pktlen < 1) goto out_too_short; cnt = (unsigned char)pkt[0]; pktlen -= 1; pkt += 1; debug(3, "num_players: %d", cnt); for(;cnt && pktlen > 0; --cnt) { unsigned idx; const char* name; struct player* p; // Index idx = *pkt++; --pktlen; // PlayerName str = memchr(pkt, '\0', pktlen); if(!str) break; name = pkt; pktlen -= str-pkt+1; pkt += str-pkt+1; if(pktlen < 8) goto out_too_short; debug(3, "player index %d", idx); p = add_player(server, server->n_player_info); if(p) { union { int i; float fl; } temp; p->name = strdup(name); // Score p->frags = ntohl( *(unsigned int *)pkt ); // TimeConnected temp.i = ntohl( *(unsigned int *)(pkt+4) ); p->connect_time = temp.fl; // Ping p->ping = 0; p->ping = ntohs( *(unsigned int *)(pkt+8) ); //((unsigned char*)&p->ping)[0] = pkt[9]; //((unsigned char*)&p->ping)[1] = pkt[8]; // ProfileId //p->profileid = ntohl( *(unsigned int *)pkt+10 ); // Team p->team = *(pkt+14); //fprintf( stderr, "Player: '%s', Frags: %u, Time: %u, Ping: %hu, Team: %d\n", p->name, p->frags, p->connect_time, p->ping, p->team ); } pktlen -= 15; pkt += 15; } #if 0 // seems to be a rather normal condition if(cnt) { malformed_packet(server, "packet contains too few players, missing %d", cnt); } #endif if(pktlen) malformed_packet(server, "garbage at end of player info, %d bytes left", pktlen); status->have_player = 1; server->retry1 = n_retries; break; default: malformed_packet(server, "invalid packet id %hhx", *--pkt); return PKT_ERROR; } if( (!get_player_info || (get_player_info && status->have_player)) && (!get_server_rules || (get_server_rules && status->have_rules)) ) { server->next_rule = NULL; } return DONE_AUTO; out_too_short: malformed_packet(server, "packet too short"); return PKT_ERROR; }