bm_dissect.cpp

#include "kage.h"
#include "bomberman.h"
#include <stdio.h>
#include <stdint.h>
#include <time.h>
#include <unistd.h>
#include <stdlib.h>
#include <map>

typedef struct __attribute__((packed))
{
  time_t ts;
  uint32_t addr;
  uint16_t port;
  uint32_t size;
} Header;

const char *commandName(int cmd)
{
	switch (cmd)
	{
	case Packet::REQ_NOP: return "NOP";
	case Packet::REQ_CHAT: return "CHAT";
	case Packet::REQ_CHG_ROOM_ATTR: return "CHG ROOM ATTR";
	case Packet::REQ_CHG_USER_STATUS: return "CHG USER STATUS";
	case Packet::REQ_CHG_USER_PROP: return "CHG USER PROP";
	case Packet::REQ_CREATE_ROOM: return "CREATE ROOM";
	case Packet::REQ_GAME_DATA: return "GAME DATA";
	case Packet::REQ_JOIN_LOBBY_ROOM: return "JOIN";
	case Packet::REQ_LEAVE_LOBBY_ROOM: return "LEAVE";
	case Packet::REQ_PING: return "PING";
	case Packet::REQ_QRY_LOBBIES: return "QRY LOBBIES";
	case Packet::REQ_QRY_ROOMS: return "QRY ROOMS";
	case Packet::REQ_QRY_USERS: return "QRY USERS";
	default:
		break;
	}
	static char s[3];
	sprintf(s, "%02x", cmd & 0xff);
	return s;
}

static void dump(const uint8_t* data, size_t len)
{
	for (unsigned i = 0; i < len; i++)
		printf(" %02x", data[i]);
	printf("\n");
}
void dumpData(const uint8_t *data, size_t len, const char *prefix = "")
{
	for (size_t i = 0; i < len;)
	{
		printf("%s", prefix);
		char ascii[17] {};
		for (int j = 0; j < 16 && i + j < len; j++) {
			uint8_t b = data[i + j];
			printf("%02x ", b);
			if (b >= ' ' && b < 0x7f)
				ascii[j] = (char)b;
			else
				ascii[j] = '.';
		}
		printf("%s\n", ascii);
		i += 16;
	}
}

void usage(const char *pname)
{
	fprintf(stderr, "%s [OPTION]... [FILE]\n", pname);
	fprintf(stderr, "    -c       Player coordinates\n");
	fprintf(stderr, "    -p       Power ups\n");
	fprintf(stderr, "    -b       Bombs\n");
	fprintf(stderr, "    -m       Brick map\n");
	fprintf(stderr, "    -t       Timestamp\n");
	fprintf(stderr, "    -f       Everything. Equivalent to -cpbmt\n");
	fprintf(stderr, "    -h       This help\n");
	fprintf(stderr, "    -s <N>   Player N only\n");
}

int main(int argc, char *argv[])
{
	int opt;
	int coords = 0;
	int powerUps = 0;
	int bombs = 0;
	int brickMap = 0;
	int slot = -1;
	int timestamp = 0;
	while ((opt = getopt(argc, argv, "cpbms:tf?h")) != -1)
	{
		switch (opt) {
		case 'c':
			coords = 1;
			break;
		case 'p':
			powerUps = 1;
			break;
		case 'b':
			bombs = 1;
			break;
		case 'm':
			brickMap = 1;
			break;
		case 's':
			slot = optarg[0] - '0';
			break;
		case 't':
			timestamp = 1;
			break;
		case 'f':
			coords = 1;
			powerUps = 1;
			bombs = 1;
			brickMap = 1;
			timestamp = 1;
			break;
		case 'h':
			usage(argv[0]);
			return 0;
		default:
			usage(argv[0]);
			return 1;
		}
	}
	FILE *fin = stdin;
	if (optind < argc)
	{
		fin = fopen(argv[optind], "rb");
		if (fin == nullptr) {
			perror(argv[optind]);
			return 1;
		}
		if (optind < argc - 1)
			fprintf(stderr, "Rest of command line arguments ignored: %s ...\n", argv[optind + 1]);
	}

	Header h;
	uint8_t buf[1500];
	time_t start = 0;
	char ip[INET_ADDRSTRLEN];
	std::map<std::pair<uint32_t, uint16_t>, uint32_t> relSeqs;
	std::map<std::pair<uint32_t, uint16_t>, int> slots;

	while (fread(&h, sizeof(h), 1, fin) == 1)
	{
		if (fread(buf, 1, h.size, fin) != h.size) {
			printf("Last packet truncated\n");
			break;
		}
		if (start == 0)
			start = h.ts;
		h.ts -= start;

		const uint8_t *data = buf;
		bool firstChunk = true;
		while (data < buf + h.size - 4)
		{
			uint32_t size = read16(data, 0) & 0x3ff;

			if (firstChunk)
			{
				if (slot != -1)
				{
					auto it = slots.find(std::make_pair(uint32_t(h.addr), uint16_t(h.port)));
					if (it != slots.end() && it->second != slot)
						break;
				}
				printf("[%02ld:%02ld:%02ld.%03ld] ", h.ts / 3600000, (h.ts % 3600000) / 60000, (h.ts % 60000) / 1000, h.ts % 1000);
				inet_ntop(AF_INET, &h.addr, ip, INET_ADDRSTRLEN);
				printf(" %15s:%d\t", ip, h.port);
				firstChunk = false;
			}
			else {
				printf("\t\t\t\t\t");
			}
			printf("%s%04x %04x ", data[0] & 0x80 ? "!" : " ", read32(data, 8), read32(data, 0xc));
			if (data[0] & 0x80)
			{
				uint32_t& relSeq = relSeqs[std::make_pair(uint32_t(h.addr), uint16_t(h.port))];
				uint32_t newSeq = read32(data, 8);
				//if (newSeq != 0 && newSeq <= relSeq)
				//	printf("***!!!*** ");
				relSeq = newSeq;
			}

			switch (data[3])
			{
			case Packet::REQ_CHAT:
				{
					uint16_t flags = read16(data, 0);
					if (flags & Packet::FLAG_RELAY) {
						printf("CHAT %s\n", &data[0x10]);
					}
					else
					{
						BMCmd cmd(read16(data, 0x10));
						switch (cmd.command)
						{
						case BMCmd::KICK_PLAYER:
							printf("bm:KICK_PLAYER\n");
							break;
						case BMCmd::PING:
							printf("bm:PING\n");
							break;
						default:
							printf("CHAT data unknown: %x\n", cmd.command);
							break;
						}
					}
					break;
				}
			case Packet::REQ_CHG_ROOM_ATTR:
				printf("CHG ROOM ATTR %x\n", read32(data, 0x14));
				break;
			case Packet::REQ_CHG_USER_STATUS:
				printf("CHG USER STATUS %x\n", read32(data, 0x10));
				break;
			case Packet::REQ_GAME_DATA:
				{
					uint16_t slot = read16(data, 0x12);
					const uint8_t eogMarker = slot & 0xff;
					if (slot != 0)
					{
						slot = (slot & 0x7fff) >> 11;
						auto key = std::make_pair(uint32_t(h.addr), uint16_t(h.port));
						if (slots.find(key) == slots.end())
							slots[key] = slot;
					}
					BMCmd cmd(read16(data, 0x10));
					switch (cmd.command)
					{
					case BMCmd::START_TIMER:
						printf("bm:START_TIMER\n");
						break;
					case BMCmd::NEXT_TIMER:
						printf("bm:NEXT_TIMER %x\n", read32(data, 0x14));
						break;
					case BMCmd::SET_RULES:
						printf("bm:SET_RULES\n");
						break;
					case BMCmd::START_BATTLE:
						printf("bm:START_GAME\n");
						break;
					case BMCmd::ACCEPT_RULES:
						printf("bm:ACCEPT_RULES\n");
						break;
					case BMCmd::ACK_RULES:
						printf("bm:ACK_RULES\n");
						break;
					case BMCmd::ACK_START:
						printf("bm:ACK_START\n");
						break;
					case BMCmd::START_GAME:
						printf("bm:START GAME\n");
						break;
					case BMCmd::RESTART_GAME:
						printf("bm:RESTART GAME\n");
						break;
					case BMCmd::END_GAME:
						printf("bm:END GAME\n");
						break;
					case BMCmd::END_BATTLE:
						printf("bm:END BATTLE\n");
						break;
					case BMCmd::MAP_INFO:
						printf("bm:MAP_INFO_A");
						dump(data + 0x10, size - 0x10);
						break;
					case BMCmd::MAP_INFO_LAST:
						printf("bm:MAP_INFO_B");
						dump(data + 0x10, size - 0x10);
						break;
					case BMCmd::BOMB_DATA:
						{
							printf("BOMB_DATA:");
							if (eogMarker != 0)
								printf(" EoG %02x", eogMarker);
							printf("\n");
							if (coords)
							{
								for (int i = 0; i < 8; i++)
								{
									CompactUser p1(data + 0x14 + sizeof(CompactUser) * i);
									if (p1.pos.x != 0 || p1.pos.y != 0)
										printf("\tP%d %g:%g st %x dir %x\n", i + 1, p1.pos.xpos(), p1.pos.ypos(), p1.status, p1.dir);
								}
							}
							if (timestamp) {
								const uint32_t time = read32(data, 0x34);
								printf("    TIMESTAMP %x\n", time);
							}
							if (bombs)
							{
								const uint8_t *p = &data[0x38];
								for (int i = 0; i < 24; i++, p += sizeof(Bomb))
								{
									Bomb bomb;
									bomb.readFrom(p);
									if (bomb.type != 0 && bomb.type != 1 && bomb.type != 4)
										printf("      [%d] Unknown type %d\n", i, bomb.type);
									if (bomb.pos.x == 0 && bomb.pos.y == 0)
										continue;
									printf("    BOMB[%d]: %d %d type %d slot %d size %d unknown %d  %04x\n",
											i, bomb.pos.x, bomb.pos.y, bomb.type, bomb.slot,
											bomb.size, bomb.unk2, bomb.param2);
								}
							}
							if (brickMap)
								dumpData(data + 0xC8, 0x10, "    bitmap ");
							break;
						}
					case BMCmd::MAP_DATA:
						{
							Position p1(read16(data, 0x14));
							Position p2(read16(data, 0x18));
							printf("MAP_DATA:");
							if (eogMarker != 0)
								printf(" EoG %02x", eogMarker);
							printf(" P1 %g:%g, P2 %g:%g\n", p1.xpos(), p1.ypos(), p2.xpos(), p2.ypos());
							if (powerUps)
							{
								const uint8_t *p = &data[0x34];
								for (int i = 0; i < 28; i++, p += 4)
								{
									PowerUp pup(data + 0x34 + sizeof(PowerUp) * i);
									if (pup.state > 1)
										printf("    POWER-UP[%d]: %d %d state %X slot %d bombUp %d bombSlot %d\n", i, pup.pos.x, pup.pos.y, pup.state,
												pup.slot, pup.bombUp, (pup.bombSlotHigh << 2) | pup.bombSlotLow);
								}
							}
							if (brickMap)
								dumpData(data + 0xA4, 0x10, "    bitmap ");
							break;
						}
					case BMCmd::POS_DATA:
						printf("POS_DATA:");
						if (eogMarker != 0)
							printf(" EoG %02x", eogMarker);
						printf("\n");
						break;

					default:
						printf("bm:UNEXPECTED %02x\n", cmd.command);
						break;
					}
					break;
				}
			default:
				printf("%s\n", commandName(data[3]));
				break;
			}

			data += size;
		}
	}
	return 0;
}