sam/minecraft-server
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

clean up

Browse source
This commit is contained in:
sam 2024-10-21 14:00:12 +13:00
parent 72703c91c2
commit 6119fc49fe
2 changed files with 46 additions and 110 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
.session.vim
View file

@ -13,11 +13,11 @@ if &shortmess =~ 'A'
else else
set shortmess=aoO set shortmess=aoO
endif endif
badd +308 ~/.config/nvim/init.lua badd +0 .gitignore
argglobal argglobal
%argdel %argdel
$argadd ~/.config/nvim/init.lua $argadd .gitignore
edit ~/.config/nvim/init.lua edit .gitignore
argglobal argglobal
setlocal fdm=manual setlocal fdm=manual
setlocal fde=0 setlocal fde=0
@ -29,12 +29,12 @@ setlocal fdn=20
setlocal fen setlocal fen
silent! normal! zE silent! normal! zE
let &fdl = &fdl let &fdl = &fdl
let s:l = 308 - ((15 * winheight(0) + 15) / 31) let s:l = 1 - ((0 * winheight(0) + 15) / 31)
if s:l < 1 | let s:l = 1 | endif if s:l < 1 | let s:l = 1 | endif
keepjumps exe s:l keepjumps exe s:l
normal! zt normal! zt
keepjumps 308 keepjumps 1
normal! 027| normal! 02|
tabnext 1 tabnext 1
if exists('s:wipebuf') && len(win_findbuf(s:wipebuf)) == 0 && getbufvar(s:wipebuf, '&buftype') isnot# 'terminal' if exists('s:wipebuf') && len(win_findbuf(s:wipebuf)) == 0 && getbufvar(s:wipebuf, '&buftype') isnot# 'terminal'
silent exe 'bwipe ' . s:wipebuf silent exe 'bwipe ' . s:wipebuf

126
src/main.c
View file

@ -3,12 +3,8 @@
#include <netinet/in.h> #include <netinet/in.h>
#include <stdint.h> #include <stdint.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h> #include <sys/types.h>
#include <unistd.h> #include <unistd.h>
#include <zlib.h>
#define MAX_CONNECTIONS 5 #define MAX_CONNECTIONS 5
#define STRING_LEN 64 #define STRING_LEN 64
@ -47,51 +43,11 @@ typedef struct {
uint16_t z_size; uint16_t z_size;
} __attribute__((packed)) level_finalize_t; } __attribute__((packed)) level_finalize_t;
int gzip_compress( void trim_string(char* str) {
unsigned char* data, size_t data_len, unsigned char** compressed_data, size_t* compressed_len) { for(int i = STRING_LEN - 1; i > 0; i--) {
int ret; if(str[i] != 0x20) break;
z_stream stream; str[i] = 0;
// Allocate memory for the compressed data, it will be freed later
*compressed_data = (unsigned char*)malloc(
data_len + (data_len / 1000) + 12); // Some extra space for safety
if(!*compressed_data) {
printf("Failed to allocate memory for compressed data.\n");
return -1;
} }
// Initialize the zlib stream
stream.zalloc = Z_NULL;
stream.zfree = Z_NULL;
stream.opaque = Z_NULL;
ret = deflateInit2(&stream, Z_DEFAULT_COMPRESSION, Z_DEFLATED, 15 | 16, 8,
Z_DEFAULT_STRATEGY); // 15 | 16 for gzip encoding
if(ret != Z_OK) {
printf("Failed to initialize zlib.\n");
return ret;
}
stream.avail_in = data_len; // Input data size
stream.next_in = data; // Input data pointer
stream.avail_out = data_len + (data_len / 1000) + 12; // Output buffer size (safe estimate)
stream.next_out = *compressed_data; // Output buffer
// Compress the data
ret = deflate(&stream, Z_FINISH);
if(ret != Z_STREAM_END) {
printf("Compression failed.\n");
deflateEnd(&stream);
free(*compressed_data);
return ret;
}
*compressed_len = stream.total_out; // Set the actual compressed length
// Clean up zlib
deflateEnd(&stream);
return Z_OK;
} }
int main() { int main() {
@ -99,10 +55,8 @@ int main() {
assert(sock >= 0 && "Failed to create socket"); assert(sock >= 0 && "Failed to create socket");
int opt = 1; int opt = 1;
if(setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt))) { int result = setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
perror("setsockopt"); assert(result == 0 && "Failed to set option to reuse socket");
exit(EXIT_FAILURE);
}
struct sockaddr_in serv_addr = { struct sockaddr_in serv_addr = {
.sin_family = AF_INET, .sin_family = AF_INET,
@ -110,17 +64,16 @@ int main() {
.sin_port = htons(25565), .sin_port = htons(25565),
}; };
int result = bind(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr)); result = bind(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr));
assert(result == 0 && "Socket bind failed"); assert(result == 0 && "Socket bind failed");
int conn;
while(1) { while(1) {
result = listen(sock, MAX_CONNECTIONS); result = listen(sock, MAX_CONNECTIONS);
assert(result == 0 && "Failed to listen on socket"); assert(result == 0 && "Failed to listen on socket");
struct sockaddr_in client_addr = { 0 }; struct sockaddr_in client_addr = { 0 };
socklen_t size = sizeof(client_addr); socklen_t size = sizeof(client_addr);
conn = accept(sock, (struct sockaddr*)&client_addr, &size); int conn = accept(sock, (struct sockaddr*)&client_addr, &size);
assert(conn >= 0 && "Failed to accept connection"); assert(conn >= 0 && "Failed to accept connection");
char client_ip[INET_ADDRSTRLEN]; char client_ip[INET_ADDRSTRLEN];
@ -133,6 +86,8 @@ int main() {
if(buf[0] == 0x00) { if(buf[0] == 0x00) {
player_ident_t* player_ident = (player_ident_t*)&buf; player_ident_t* player_ident = (player_ident_t*)&buf;
trim_string(player_ident->username);
trim_string(player_ident->key);
if(player_ident->protocol_version == 0) { if(player_ident->protocol_version == 0) {
continue; continue;
@ -141,61 +96,42 @@ int main() {
printf("Protocol Version: %x\nUsername: %s\nVerification Key: %s\n", printf("Protocol Version: %x\nUsername: %s\nVerification Key: %s\n",
player_ident->protocol_version, player_ident->username, player_ident->key); player_ident->protocol_version, player_ident->username, player_ident->key);
server_ident_t server_ident = { send(conn,
&(server_ident_t){
.packet_id = 0x00, .packet_id = 0x00,
.protocol_version = 0x07, .protocol_version = 0x07,
.name = "hello", .name = "hello",
.motd = "world", .motd = "world",
.user_type = 0x64, .user_type = 0x00,
}; },
sizeof(server_ident_t), 0);
result = send(conn, &server_ident, sizeof(server_ident_t), 0); send(conn,
printf("%d bytes sent\n", result); &(level_initialize_t){
level_initialize_t level_initialize = {
.packet_id = 0x02, .packet_id = 0x02,
}; },
sizeof(level_initialize_t), 0);
result = send(conn, &level_initialize, sizeof(level_initialize_t), 0); send(conn,
printf("%d bytes sent\n", result); &(chunk_t){
uint8_t chunk_data[16 * 16 * 2];
memset(chunk_data, 1, sizeof(chunk_data));
uint8_t* compressed_chunk;
size_t compressed_size;
result = gzip_compress(chunk_data, sizeof(chunk_data), &compressed_chunk, &compressed_size);
printf("Status: %d, compressed: %zu\n", result, compressed_size);
chunk_t chunk = {
.packet_id = 0x03, .packet_id = 0x03,
.length = htons(compressed_size), .length = 0,
.data = { 0 }, .data = { 0 },
.percent_complete = 100, .percent_complete = 100,
}; },
memcpy(chunk.data, compressed_chunk, compressed_size); sizeof(chunk_t), 0);
for(int i = 0; i < sizeof(chunk); i++) { send(conn,
printf("0x%02x ", ((unsigned char*)&chunk)[i]); &(level_finalize_t){
}
printf("\n");
result = send(conn, &chunk, sizeof(chunk_t), 0);
printf("%d bytes sent\n", result);
level_finalize_t level_finalize = {
.packet_id = 0x04, .packet_id = 0x04,
.x_size = htons(16), .x_size = htons(0),
.y_size = htons(1), .y_size = htons(0),
.z_size = htons(16), .z_size = htons(0),
}; },
sizeof(level_finalize_t), 0);
result = send(conn, &level_finalize, sizeof(level_finalize_t), 0);
printf("%d bytes sent\n", result);
} }
} }
close(conn);
close(sock); close(sock);
return 0; return 0;