Ledda/djstdlib
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

working chat app example with some rough edges

Browse Source
This commit is contained in:
Daniel Ledda
2025-11-30 20:01:06 +01:00
parent f311b242c2
commit 875cd9d044
5 changed files with 346 additions and 105 deletions
Download Patch File Download Diff File Expand all files Collapse all files

269
app.c
View File

@@ -1,121 +1,208 @@
#include "core.h"
#define DJSTD_BASIC_ENTRY
#include "core.c"
#include "signal.h"
#include "stdlib.h"
Server *server = NULL;
Server *openServer = NULL;
SocketList *openSockets = NULL;
void handleSigint(int dummy) {
if (server) {
if (openServer) {
println("");
println("Closing server socket.");
serverClose(server);
serverClose(openServer);
println("Success.");
}
if (openSockets && openSockets->length) {
println("");
println("Closing open sockets.");
for (EachEl(*openSockets, Socket, socket)) {
socketClose(socket);
}
println("Success.");
}
signal(SIGINT, SIG_DFL);
raise(SIGINT);
}
typedef struct ChatClient ChatClient;
struct ChatClient {
Socket *socket;
string nickname;
};
DefineList(ChatClient, ChatClient);
void startServer(Arena *arena, int32 port) {
println("Starting server...");
Server server = serverInit((ServerInitInfo){
.concurrentClients=2,
.port=port,
.memory=Megabytes(64),
.maxEvents=64,
});
openServer = &server;
serverListen(&server);
if (server.listening) {
println("Listening on port %d", port);
}
Arena *serverLoopArena = arenaAlloc(Megabytes(64));
ChatClientList chatClients = PushListZero(arena, ChatClientList, 256);
Forever {
ServerEvent *nextEvent;
do {
nextEvent = serverGetNextEvent(&server);
switch (nextEvent->type) {
case ServerEventType_AcceptClient: {
Socket *client = serverAccept(&server);
if (client != NULL) {
println("New client connected from %d", client->address);
}
break;
};
case ServerEventType_ClientMessage: {
StringResult clientMsg = socketReadStr(serverLoopArena, nextEvent->tClientMessage.client);
ChatClient *chatClient = NULL;
if (clientMsg.valid) {
if (strStartsWith(clientMsg.result, s("hello-"))) {
StringList nickSplit = strSplit(serverLoopArena, s("-"), clientMsg.result);
if (nickSplit.length == 2 && nickSplit.data[1].length > 0) {
string newNick = PushString(arena, nickSplit.data[1].length);
newNick.length = nickSplit.data[1].length;
memcpy(newNick.str, nickSplit.data[1].str, nickSplit.data[1].length);
ChatClient newChatClient = (ChatClient){
.socket=nextEvent->tClientMessage.client,
.nickname=newNick,
};
AppendList(&chatClients, newChatClient);
println("Client from %d calls themselves \"%S\"", newChatClient.socket->address, newChatClient.nickname);
}
} else {
for (EachEl(chatClients, ChatClient, maybeChatClient)) {
if (maybeChatClient->socket->handle == nextEvent->tClientMessage.client->handle) {
chatClient = maybeChatClient;
}
}
if (chatClient != NULL) {
if (strStartsWith(clientMsg.result, s("say-"))) {
StringList saySplit = strSplit(arena, s("-"), clientMsg.result);
if (saySplit.length == 2 && saySplit.data[1].length > 0) {
string broadcast = strPrintf(serverLoopArena, "%S says:\n%S", chatClient->nickname, saySplit.data[1]);
for (EachEl(server.clients, Socket, client)) {
socketWriteStr(client, broadcast);
}
}
} else {
// Invalid client message
}
}
}
}
break;
};
case ServerEventType_None: {
break;
};
default:
break;
}
} while (nextEvent != NULL);
arenaFreeFrom(serverLoopArena, 0);
}
println("Shutting down chat.");
serverClose(&server);
}
void clearStdInLn() {
print("\r");
print(ANSI_INSTRUCTION(J));
}
void clearStdInLnAfterInput() {
print("\r");
print(ANSI_INSTRUCTION(A));
print(ANSI_INSTRUCTION(J));
}
void startClient(Arena *arena, string addr, int32 port, string nickname) {
fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
println("Connecting to server at [%S]:%d with nickname \"%S\"", addr, port, nickname);
Socket server = socketConnect(arena, (SocketConnectInfo){ .address=addr, .port=port });
if (server.closed) {
println("Connection error. Closing.");
} else {
println("Connected successfully");
string message = strPrintf(arena, "hello-%S", nickname);
CharList inputBuf = PushList(arena, CharList, 512);
socketWriteStr(&server, message);
print("(you)> ");
Forever {
Scratch scratch = scratchStart(&arena, 1);
int32 numRead = read(0, inputBuf.data + inputBuf.length, inputBuf.capacity - inputBuf.length);
if (numRead >= 0) {
inputBuf.length += numRead;
if (inputBuf.data[inputBuf.length - 1] == '\n') {
clearStdInLnAfterInput();
socketWriteStr(&server, strPrintf(scratch.arena, "say-%S", (string){.str=inputBuf.data,.length=inputBuf.length}));
inputBuf.length = 0;
}
}
StringResult serverMsg = socketReadStr(scratch.arena, &server);
if (serverMsg.valid && serverMsg.result.length > 0) {
clearStdInLn();
println("%S", serverMsg.result);
print("(you)> %S", (string){.str=inputBuf.data, inputBuf.length});
}
scratchEnd(scratch);
}
}
socketClose(&server);
}
int djstd_entry(Arena *arena, StringList args) {
signal(SIGINT, &handleSigint);
bool argumentErr = true;
bool isServer = strEql(args.data[0], s("server"));
bool isClient = strEql(args.data[0], s("client"));
if (!isServer && !isClient || args.length < 2) {
println("Usage: [type] [port] ([remote_address])");
println("[type] is either 'server' or 'client'");
println("[remote_address] can be given if a client app, default is loopback");
return 0;
}
int port = 8080;
Int32Result portParsed = parsePositiveInt(args.data[1]);
if (portParsed.valid) {
port = portParsed.result;
}
string addr = s("::1");
if (!isServer && args.length > 2) {
if (args.data[2].length > 0) {
addr = args.data[2];
}
}
if (isServer) {
println("Starting server on port %d", port);
Server myserver = serverInit((ServerInitInfo){
.concurrentClients=2,
.port=port,
.memory=Megabytes(64),
});
server = &myserver;
serverListen(&myserver);
Socket *client1 = serverAccept(&myserver);
Socket *client2 = serverAccept(&myserver);
Forever {
string message = s("Hello. You are client 1.\n");
socketWrite(client1, message.str, message.length);
message = s("Hello. You are client 2.\n");
socketWrite(client2, message.str, message.length);
string buf = PushStringFill(arena, 256, 0);
uint64 bytesRead = socketRead(client1, buf.str, buf.length - 1);
if (bytesRead > 0) {
buf.length = bytesRead;
string message = strSplit(arena, s("\n"), buf).data[0];
message = strPrintf(arena, "Client 1 said: %S\n", message);
println("%S", message);
socketWrite(client2, message.str, message.length);
println("Saying goodbye to everyone");
message = s("Goodbye\n");
socketWrite(client1, message.str, message.length);
socketWrite(client2, message.str, message.length);
break;
}
Int32Result portParsed = parsePositiveInt(args.data[1]);
if (portParsed.valid) {
startServer(arena, portParsed.result);
argumentErr = false;
}
socketClose(client1);
socketClose(client2);
serverClose(&myserver);
} else {
println("Connecting to socket at %S on port %d", addr, port);
Socket sock = socketConnect(arena, (SocketConnectInfo){ .address=addr, .port=port });
if (sock.closed) {
println("Connection error. Closing.");
} else {
string message;
uint64 bytesWritten;
string buf = PushStringFill(arena, 256, 0);
socketRead(&sock, buf.str, buf.length);
string messageReceived = strSplit(arena, s("\n"), buf).data[0];
println("%S", strPrintf(arena, "Server said: %S", messageReceived));
if (strEql(messageReceived, s("Hello. You are client 1."))) {
string broadcast = s("HELLO WORLD!!!!\n");
socketWrite(&sock, broadcast.str, broadcast.length);
}
Forever {
socketRead(&sock, buf.str, buf.length);
messageReceived = strSplit(arena, s("\n"), buf).data[0];
println("Server said: %S", messageReceived);
if (strEql(messageReceived, s("Goodbye"))) {
println("Quitting");
break;
} else if (isClient) {
if (args.length == 3) {
StringList split = strSplit(arena, s("]:"), args.data[1]);
if (split.length == 2) {
Int32Result portParsed = parsePositiveInt(split.data[1]);
string addr = strSlice(split.data[0], 1, split.data[0].length);
string nickname = args.data[2];
if (portParsed.valid && addr.length > 0 && nickname.length > 0) {
startClient(arena, addr, portParsed.result, nickname);
argumentErr = false;
}
}
}
}
socketClose(&sock);
if (argumentErr) {
println("Usage:");
println("server [PORT]");
println("OR");
println("client [REMOTE_ADDRESS:PORT] [NICKNAME]");
}
return 0;