handle_bnet.c

打魔兽战网的都知道他是什么

	    }

	    conn_push_outqueue(c, rpacket);
	    packet_del_ref(rpacket);
	}
    }

    return 0;
}

static int _client_regsnoopreply(t_connection * c, t_packet const *const packet)
{
    if (packet_get_size(packet) < sizeof(t_client_regsnoopreply)) {
	eventlog(eventlog_level_error, __FUNCTION__, "[%d] got bad REGSNOOPREPLY packet (expected %u bytes, got %u)", conn_get_socket(c), sizeof(t_client_regsnoopreply), packet_get_size(packet));
	return -1;
    }
    return 0;
}

static int _client_iconreq(t_connection * c, t_packet const *const packet)
{
    t_packet *rpacket;

    if (packet_get_size(packet) < sizeof(t_client_iconreq)) {
	eventlog(eventlog_level_error, __FUNCTION__, "[%d] got bad ICONREQ packet (expected %u bytes, got %u)", conn_get_socket(c), sizeof(t_client_iconreq), packet_get_size(packet));
	return -1;
    }

    if ((rpacket = packet_create(packet_class_bnet))) {
	packet_set_size(rpacket, sizeof(t_server_iconreply));
	packet_set_type(rpacket, SERVER_ICONREPLY);
	file_to_mod_time(prefs_get_iconfile(), &rpacket->u.server_iconreply.timestamp);

	/* battle.net sends different file on iconreq for WAR3 and W3XP [Omega] */
	if ((conn_get_clienttag(c) == CLIENTTAG_WARCRAFT3_UINT) || (conn_get_clienttag(c) == CLIENTTAG_WAR3XP_UINT))
	    packet_append_string(rpacket, prefs_get_war3_iconfile());
	/* battle.net still sends "icons.bni" to sc/bw clients
	 * clients request icons_STAR.bni seperatly */
/*	else if (strcmp(conn_get_clienttag(c),CLIENTTAG_STARCRAFT)==0)
	    packet_append_string(rpacket,prefs_get_star_iconfile());
	else if (strcmp(conn_get_clienttag(c),CLIENTTAG_BROODWARS)==0)
	    packet_append_string(rpacket,prefs_get_star_iconfile());
 */
	else
	    packet_append_string(rpacket, prefs_get_iconfile());

	conn_push_outqueue(c, rpacket);
	packet_del_ref(rpacket);
    }

    return 0;
}

static int _client_cdkey(t_connection * c, t_packet const *const packet)
{
    t_packet *rpacket;

    if (packet_get_size(packet) < sizeof(t_client_cdkey)) {
	eventlog(eventlog_level_error, __FUNCTION__, "[%d] got bad CDKEY packet (expected %u bytes, got %u)", conn_get_socket(c), sizeof(t_client_cdkey), packet_get_size(packet));
	return -1;
    }

    {
	char const *cdkey;
	char const *owner;

	if (!(cdkey = packet_get_str_const(packet, sizeof(t_client_cdkey), MAX_CDKEY_STR))) {
	    eventlog(eventlog_level_error, __FUNCTION__, "[%d] got bad CDKEY packet (missing or too long cdkey)", conn_get_socket(c));
	    return -1;
	}
	if (!(owner = packet_get_str_const(packet, sizeof(t_client_cdkey) + strlen(cdkey) + 1, MAX_OWNER_STR))) {
	    eventlog(eventlog_level_error, __FUNCTION__, "[%d] got bad CDKEY packet (missing or too long owner)", conn_get_socket(c));
	    return -1;
	}

	conn_set_cdkey(c, cdkey);
	conn_set_owner(c, owner);

	if ((rpacket = packet_create(packet_class_bnet))) {
	    packet_set_size(rpacket, sizeof(t_server_cdkeyreply));
	    packet_set_type(rpacket, SERVER_CDKEYREPLY);
	    bn_int_set(&rpacket->u.server_cdkeyreply.message, SERVER_CDKEYREPLY_MESSAGE_OK);
	    packet_append_string(rpacket, owner);
	    conn_push_outqueue(c, rpacket);
	    packet_del_ref(rpacket);
	}
    }
#if 0				/* Blizzard used this to track down pirates, should only be accepted by old clients */
    if ((rpacket = packet_create(packet_class_bnet))) {
	packet_set_size(rpacket, sizeof(t_server_regsnoopreq));
	packet_set_type(rpacket, SERVER_REGSNOOPREQ);
	bn_int_set(&rpacket->u.server_regsnoopreq.unknown1, SERVER_REGSNOOPREQ_UNKNOWN1);	/* sequence num */
	bn_int_set(&rpacket->u.server_regsnoopreq.hkey, SERVER_REGSNOOPREQ_HKEY_CURRENT_USER);
	packet_append_string(rpacket, SERVER_REGSNOOPREQ_REGKEY);
	packet_append_string(rpacket, SERVER_REGSNOOPREQ_REGVALNAME);
	conn_push_outqueue(c, rpacket);
	packet_del_ref(rpacket);
    }
#endif
    return 0;
}

static int _client_cdkey2(t_connection * c, t_packet const *const packet)
{
    t_packet *rpacket;

    if (packet_get_size(packet) < sizeof(t_client_cdkey2)) {
	eventlog(eventlog_level_error, __FUNCTION__, "[%d] got bad CDKEY2 packet (expected %u bytes, got %u)", conn_get_socket(c), sizeof(t_client_cdkey2), packet_get_size(packet));
	return -1;
    }

    {
	char const *owner;

	if (!(owner = packet_get_str_const(packet, sizeof(t_client_cdkey2), MAX_OWNER_STR))) {
	    eventlog(eventlog_level_error, __FUNCTION__, "[%d] got bad CDKEY2 packet (missing or too long owner)", conn_get_socket(c));
	    return -1;
	}

	conn_set_owner(c, owner);

	if ((rpacket = packet_create(packet_class_bnet))) {
	    packet_set_size(rpacket, sizeof(t_server_cdkeyreply2));
	    packet_set_type(rpacket, SERVER_CDKEYREPLY2);
	    bn_int_set(&rpacket->u.server_cdkeyreply2.message, SERVER_CDKEYREPLY2_MESSAGE_OK);
	    packet_append_string(rpacket, owner);
	    conn_push_outqueue(c, rpacket);
	    packet_del_ref(rpacket);
	}
    }

    return 0;
}

static int _client_cdkey3(t_connection * c, t_packet const *const packet)
{
    t_packet *rpacket;

    if (packet_get_size(packet) < sizeof(t_client_cdkey3)) {
	eventlog(eventlog_level_error, __FUNCTION__, "[%d] got bad CDKEY3 packet (expected %u bytes, got %u)", conn_get_socket(c), sizeof(t_client_cdkey2), packet_get_size(packet));
	return -1;
    }

    {
	char const *owner;

	if (!(owner = packet_get_str_const(packet, sizeof(t_client_cdkey3), MAX_OWNER_STR))) {
	    eventlog(eventlog_level_error, __FUNCTION__, "[%d] got bad CDKEY3 packet (missing or too long owner)", conn_get_socket(c));
	    return -1;
	}

	conn_set_owner(c, owner);

	if ((rpacket = packet_create(packet_class_bnet))) {
	    packet_set_size(rpacket, sizeof(t_server_cdkeyreply3));
	    packet_set_type(rpacket, SERVER_CDKEYREPLY3);
	    bn_int_set(&rpacket->u.server_cdkeyreply3.message, SERVER_CDKEYREPLY3_MESSAGE_OK);
	    packet_append_string(rpacket, "");	/* FIXME: owner, message, ??? */
	    conn_push_outqueue(c, rpacket);
	    packet_del_ref(rpacket);
	}
    }

    return 0;
}

static int _client_udpok(t_connection * c, t_packet const *const packet)
{
    if (packet_get_size(packet) < sizeof(t_client_udpok)) {
	eventlog(eventlog_level_error, __FUNCTION__, "[%d] got bad UDPOK packet (expected %u bytes, got %u)", conn_get_socket(c), sizeof(t_client_udpok), packet_get_size(packet));
	return -1;
    }
    /* we could check the contents but there really isn't any point */
    conn_set_udpok(c);

    return 0;
}

static int _client_fileinforeq(t_connection * c, t_packet const *const packet)
{
    t_packet *rpacket;

    if (packet_get_size(packet) < sizeof(t_client_fileinforeq)) {
	eventlog(eventlog_level_error, __FUNCTION__, "[%d] got bad FILEINFOREQ packet (expected %u bytes, got %u)", conn_get_socket(c), sizeof(t_client_fileinforeq), packet_get_size(packet));
	return -1;
    }

    {
	char const *tosfile;

	if (!(tosfile = packet_get_str_const(packet, sizeof(t_client_fileinforeq), MAX_FILENAME_STR))) {
	    eventlog(eventlog_level_error, __FUNCTION__, "[%d] got bad FILEINFOREQ packet (missing or too long tosfile)", conn_get_socket(c));
	    return -1;
	}
	eventlog(eventlog_level_info, __FUNCTION__, "[%d] TOS requested: \"%s\" - type = 0x%02x", conn_get_socket(c), tosfile, bn_int_get(packet->u.client_fileinforeq.type));

	/* TODO: if type is TOSFILE make bnetd to send default tosfile if selected is not found */
	if ((rpacket = packet_create(packet_class_bnet))) {
	    packet_set_size(rpacket, sizeof(t_server_fileinforeply));
	    packet_set_type(rpacket, SERVER_FILEINFOREPLY);
	    bn_int_set(&rpacket->u.server_fileinforeply.type, bn_int_get(packet->u.client_fileinforeq.type));
	    bn_int_set(&rpacket->u.server_fileinforeply.unknown2, bn_int_get(packet->u.client_fileinforeq.unknown2));
	    /* Note from Sherpya:
	     * timestamp -> 0x852b7d00 - 0x01c0e863 b.net send this (bn_int),
	     * I suppose is not a long 
	     * if bnserver-D2DV is bad diablo 2 crashes 
	     * timestamp doesn't work correctly and starcraft 
	     * needs name in client locale or displays hostname
	     */
	    file_to_mod_time(tosfile, &rpacket->u.server_fileinforeply.timestamp);
	    packet_append_string(rpacket, tosfile);
	    conn_push_outqueue(c, rpacket);
	    packet_del_ref(rpacket);
	}
    }

    return 0;
}

static const char *_attribute_req(t_account * reqacc, t_account * myacc, const char *key)
{
    const char *result = "";
    const char *tval;

    if (!reqacc)
	goto out;
    if (reqacc != myacc && !strncasecmp(key, "BNET", 4))
	goto out;

    tval = account_get_strattr(reqacc, key);
    if (tval)
	result = tval;

  out:
    return result;
}

static int _client_statsreq(t_connection * c, t_packet const *const packet)
{
    t_packet *rpacket;
    char const *name;
    char const *key;
    unsigned int name_count;
    unsigned int key_count;
    unsigned int i, j;
    unsigned int name_off;
    unsigned int keys_off;
    unsigned int key_off;
    t_account *reqacc, *myacc;

    if (packet_get_size(packet) < sizeof(t_client_statsreq)) {
	eventlog(eventlog_level_error, __FUNCTION__, "[%d] got bad STATSREQ packet (expected %u bytes, got %u)", conn_get_socket(c), sizeof(t_client_statsreq), packet_get_size(packet));
	return -1;
    }

    name_count = bn_int_get(packet->u.client_statsreq.name_count);
    key_count = bn_int_get(packet->u.client_statsreq.key_count);

    for (i = 0, name_off = sizeof(t_client_statsreq); i < name_count && (name = packet_get_str_const(packet, name_off, UNCHECKED_NAME_STR)); i++, name_off += strlen(name) + 1);

    if (i < name_count) {
	eventlog(eventlog_level_error, __FUNCTION__, "[%d] got bad STATSREQ packet (only %u names of %u)", conn_get_socket(c), i, name_count);
	return -1;
    }
    keys_off = name_off;

    if (!(rpacket = packet_create(packet_class_bnet)))
	return -1;

    packet_set_size(rpacket, sizeof(t_server_statsreply));
    packet_set_type(rpacket, SERVER_STATSREPLY);
    bn_int_set(&rpacket->u.server_statsreply.name_count, name_count);
    bn_int_set(&rpacket->u.server_statsreply.key_count, key_count);
    bn_int_set(&rpacket->u.server_statsreply.requestid, bn_int_get(packet->u.client_statsreq.requestid));

    myacc = conn_get_account(c);

    for (i = 0, name_off = sizeof(t_client_statsreq); i < name_count && (name = packet_get_str_const(packet, name_off, UNCHECKED_NAME_STR)); i++, name_off += strlen(name) + 1) {
	reqacc = accountlist_find_account(name);
	if (!reqacc)
	    reqacc = myacc;

	for (j = 0, key_off = keys_off; j < key_count && (key = packet_get_str_const(packet, key_off, MAX_ATTRKEY_STR)); j++, key_off += strlen(key) + 1) {
	    if (*key == '\0')
		continue;
	    packet_append_string(rpacket, _attribute_req(reqacc, myacc, key));
	}
    }

    conn_push_outqueue(c, rpacket);
    packet_del_ref(rpacket);

    return 0;
}

static int _client_loginreq1(t_connection * c, t_packet const *const packet)
{
    t_packet *rpacket;

    if (packet_get_size(packet) < sizeof(t_client_loginreq1)) {
	eventlog(eventlog_level_error, __FUNCTION__, "[%d] got bad LOGINREQ1 packet (expect