Exemplos de client_send_packet em C++ (Cpp)

Exemplo n.º 1

Arquivo: packet_open_window.c Projeto: Adam-/bedrock

void packet_send_open_window(struct client *client, uint8_t type, const char *title, uint8_t slots)
{
    bedrock_packet packet;
    uint8_t use_title = 1;

    if (!title)
    {
        title = "";
        use_title = 0;
    }

    while (++window_id == 0);

#if 0
    packet_init(&packet, SERVER_OPEN_WINDOW);

    packet_pack_byte(&packet, window_id);
    packet_pack_byte(&packet, type);
    packet_pack_string(&packet, title);
    packet_pack_byte(&packet, slots);
    packet_pack_byte(&packet, use_title);

    client_send_packet(client, &packet);

    client->window_data.id = window_id;
    client->window_data.type = type;
#endif
}

Exemplo n.º 2

Arquivo: packet_destroy_entity.c Projeto: Justasic/bedrock

void packet_send_destroy_entity_player(struct client *client, struct client *c)
{
	bedrock_packet packet;
	uint8_t count = 1;

	packet_init(&packet, SERVER_DESTROY_ENTITY);

	packet_pack_int(&packet, &count, sizeof(count));
	packet_pack_int(&packet, &c->id, sizeof(c->id));

	client_send_packet(client, &packet);
}

Exemplo n.º 3

Arquivo: packet_destroy_entity.c Projeto: Justasic/bedrock

void packet_send_destroy_entity_dropped_item(struct client *client, struct dropped_item *di)
{
	bedrock_packet packet;
	uint8_t count = 1;

	packet_init(&packet, SERVER_DESTROY_ENTITY);

	packet_pack_int(&packet, &count, sizeof(count));
	packet_pack_int(&packet, &di->eid, sizeof(di->eid));

	client_send_packet(client, &packet);
}

Exemplo n.º 4

Arquivo: packet_update_window_property.c Projeto: Justasic/bedrock

void packet_send_update_window_property(struct client *client, int8_t window_id, int16_t property, int16_t value)
{
	bedrock_packet packet;

	packet_init(&packet, SERVER_UPDATE_WINDOW_PROPERTY);

	packet_pack_int(&packet, &window_id, sizeof(window_id));
	packet_pack_int(&packet, &property, sizeof(property));
	packet_pack_int(&packet, &value, sizeof(value));

	client_send_packet(client, &packet);
}

Exemplo n.º 5

Arquivo: packet_player_list_item.c Projeto: Adam-/bedrock

void packet_send_player_list_item(struct client *client, struct client *c, uint8_t online)
{
	bedrock_packet packet;

#if 0
	packet_init(&packet, SERVER_PLAYER_LIST);

	packet_pack_string(&packet, c->name);
	packet_pack_byte(&packet, online);
	packet_pack_short(&packet, c->ping);

	client_send_packet(client, &packet);
#endif
}

Exemplo n.º 6

Arquivo: packet_set_slot.c Projeto: Justasic/bedrock

void packet_send_set_slot(struct client *client, uint8_t window_id, uint16_t slot, struct item *item, uint8_t count, int16_t damage)
{
	bedrock_packet packet;
	struct item_stack slot_data;

	slot_data.id = item != NULL ? item->id : -1;
	slot_data.count = count;
	slot_data.metadata = damage;

	packet_init(&packet, SERVER_SET_SLOT);

	packet_pack_int(&packet, &window_id, sizeof(window_id));
	packet_pack_int(&packet, &slot, sizeof(slot));
	packet_pack_slot(&packet, &slot_data);

	client_send_packet(client, &packet);
}

Exemplo n.º 7

Arquivo: packet_encryption_request.c Projeto: Justasic/bedrock

void packet_send_encryption_request(struct client *client)
{
	int16_t pubkey_len = crypto_pubkey_len();
	int16_t verify_token_length = BEDROCK_VERIFY_TOKEN_LEN;
	bedrock_packet packet;

	packet_init(&packet, LOGIN_SERVER_ENCRYPTION_REQUEST);

	packet_pack_string(&packet, "-"); // server ID

	packet_pack_int(&packet, &pubkey_len, sizeof(pubkey_len));
	packet_pack(&packet, crypto_pubkey(), pubkey_len);

	packet_pack_int(&packet, &verify_token_length, sizeof(verify_token_length));
	packet_pack(&packet, crypto_auth_token(), BEDROCK_VERIFY_TOKEN_LEN);

	client_send_packet(client, &packet);
}

Exemplo n.º 8

Arquivo: airserv-ng.c Projeto: esurharun/aircrack-ng-cell

static void handle_card(struct sstate *ss)
{
	unsigned char buf[2048];
	int rd;
	struct rx_info *ri = (struct rx_info*) buf;
	struct client *c;

	rd = card_read(ss, ri + 1, sizeof(buf) - sizeof(*ri), ri);
    if (rd >= 0)
    	rd += sizeof(*ri);

#ifdef __MACH__
	ri->ri_mactime = OSSwapHostToBigInt64(ri->ri_mactime);
	ri->ri_power = OSSwapHostToBigInt32(ri->ri_power);
	ri->ri_noise = OSSwapHostToBigInt32(ri->ri_noise);
	ri->ri_channel = OSSwapHostToBigInt32(ri->ri_channel);
	ri->ri_rate = OSSwapHostToBigInt32(ri->ri_rate);
	ri->ri_antenna = OSSwapHostToBigInt32(ri->ri_antenna);

#elif defined(__FreeBSD__)
#if BYTE_ORDER == BIG_ENDIAN
# define __be32_to_cpu(x)       (x)
# define __be64_to_cpu(x)       (x)
#elif BYTE_ORDER == LITTLE_ENDIAN
# define __be32_to_cpu(x)       __bswap32(x)
# define __be64_to_cpu(x)       __bswap64(x)
#endif

#else
	ri->ri_mactime = __cpu_to_be64(ri->ri_mactime);
	ri->ri_power = __cpu_to_be32(ri->ri_power);
	ri->ri_noise = __cpu_to_be32(ri->ri_noise);
	ri->ri_channel = __cpu_to_be32(ri->ri_channel);
	ri->ri_rate = __cpu_to_be32(ri->ri_rate);
	ri->ri_antenna = __cpu_to_be32(ri->ri_antenna);
#endif /* __MACH__ */

	c = ss->ss_clients.c_next;
	while (c != &ss->ss_clients) {
		client_send_packet(ss, c, buf, rd);
		c = c->c_next;
	}
}

Exemplo n.º 9

Arquivo: packet_join_game.c Projeto: Justasic/bedrock

void packet_send_join_game(struct client *client)
{
	bedrock_packet packet;
	int32_t dimension;
	uint8_t b;

	nbt_copy(client->data, TAG_INT, &dimension, sizeof(dimension), 1, "Dimension");

	packet_init(&packet, SERVER_JOIN_GAME);

	packet_pack_int(&packet, &client->id, sizeof(client->id)); /* Entity ID */
	b = client->gamemode;
	packet_pack_int(&packet, &b, sizeof(b));
	b = dimension;
	packet_pack_int(&packet, &b, sizeof(b));
	packet_pack_int(&packet, nbt_read(client->world->data, TAG_BYTE, 2, "Data", "hardcore"), sizeof(uint8_t)); /* hardcore */
	b = server_maxusers;
	packet_pack_int(&packet, &b, sizeof(b)); /* Max players */
	packet_pack_string(&packet, nbt_read_string(client->world->data, 2, "Data", "generatorName")); /* Level type */

	client_send_packet(client, &packet);

	bedrock_assert(client->state == STATE_LOGGED_IN, ;);