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

improving sockets, fixed some bugs

Browse Source
This commit is contained in:
Daniel Ledda
2025-11-28 15:29:24 +01:00
parent 9b772e2046
commit 45d3f28546
5 changed files with 225 additions and 81 deletions
Download Patch File Download Diff File Expand all files Collapse all files

103
app.c
View File

@@ -2,51 +2,102 @@
#include "core.c"
#include "signal.h"
#include "stdlib.h"
Server *server = NULL;
void handleSigint(int dummy) {
if (server) {
print("\n");
print("Closing server socket.\n");
println("");
println("Closing server socket.");
serverClose(server);
print("Success\n.");
println("Success.");
}
exit(0);
signal(SIGINT, SIG_DFL);
raise(SIGINT);
}
int djstd_entry(Arena *arena, StringList args) {
signal(SIGINT, &handleSigint);
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[0]);
Int32Result portParsed = parsePositiveInt(args.data[1]);
if (portParsed.valid) {
port = portParsed.result;
}
print("Starting server on port %d\n", port);
Server myserver = serverInit((ServerInitInfo){
.concurrentClients=16,
.port=port,
.memory=Megabytes(64),
});
server = &myserver;
serverListen(&myserver);
Client *client = serverAccept(&myserver);
CharList buf = PushFullListZero(arena, CharList, 257);
uint64 bytesRead = clientRead(client, (void *)buf.data, buf.length - 1);
if (bytesRead > 0) {
print("Client said: %s\n", buf.data);
print("Now that's insightful.\n");
} else if (bytesRead == -1) {
print("Connection error\n");
string addr = s("::1");
if (!isServer && args.length > 2) {
if (args.data[2].length > 0) {
addr = args.data[2];
}
}
clientClose(client);
if (isServer) {
println("Starting server on port %d", port);
Server myserver = serverInit((ServerInitInfo){
.concurrentClients=16,
.port=port,
.memory=Megabytes(64),
});
server = &myserver;
serverListen(&myserver);
Socket *client = serverAccept(&myserver);
forever {
string buf = PushStringFill(arena, 256, 0);
uint64 bytesRead = socketRead(client, buf.str, buf.length - 1);
if (bytesRead > 0) {
buf.length = bytesRead;
println("Client said: %S", strSplit(arena, s("\n"), buf).data[0]);
println("Saying goodbye");
string message = s("Goodbye\n");
socketWrite(client, message.str, message.length);
break;
}
serverClose(&myserver);
}
socketClose(client);
} else {
println("Connecting to socket at %S on port %d", addr, port);
Socket sock = socketConnect(arena, (SocketConnectInfo){ .address=addr, .port=port });
println("CONNECTED");
string message;
uint64 bytesWritten;
string buf = PushStringFill(arena, 256, 0);
forever {
message = s("Howdy partner\n");
print("Saying: %S", message);
bytesWritten = socketWrite(&sock, message.str, message.length);
socketRead(&sock, buf.str, buf.length);
message = strSplit(arena, s("\n"), buf).data[0];
println("Received message: %S", message);
if (strEql(message, s("Goodbye"))) {
println("Quitting");
break;
}
}
socketClose(&sock);
}
return 0;
}

37
core.c
View File

@@ -71,9 +71,6 @@ Scratch scratchStart(Arena **conflicts, size_t conflictCount) {
return scratch;
}
#define DeferLoop(begin_stmnt, end_stmnt) for(int __defer_i = ((begin_stmnt), 0); __defer_i < 1; (++__defer_i, (end_stmnt)))
#define WithScratch(scratchName) Scratch scratchName; DeferLoop(scratchName = scratchStart(0, 0), scratchEnd(scratchName))
void scratchEnd(Scratch scratch) {
arenaFreeFrom(scratch.arena, scratch.start);
}
@@ -206,8 +203,8 @@ StringList strSplit(Arena *arena, string splitStr, string inputStr) {
size_t splitCount = 0;
size_t c = 0;
size_t start = 0;
void *beginning = (char *)arena->memory + arena->head;
while (c < inputStr.length - splitStr.length) {
void *beginning = arena->memory + arena->head;
while (c < inputStr.length) {
string mystr = strSlice(inputStr, c, c + splitStr.length);
if (strEql(mystr, splitStr)) {
string *splitString = PushStruct(arena, string);
@@ -337,13 +334,20 @@ string formatTimeYmd(Arena *arena, Timestamp *time) {
return buf;
}
void printStderr(const char *fmt, ...) {
function void printStderr(const char *fmt, ...) {
va_list argList;
va_start(argList, fmt);
os_print(StdStream_stdout, fmt, argList);
va_end(argList);
}
function void printlnStderr(const char *fmt, ...) {
va_list argList;
va_start(argList, fmt);
os_println(StdStream_stdout, fmt, argList);
va_end(argList);
}
function void printStdout(const char *fmt, ...) {
va_list argList;
va_start(argList, fmt);
@@ -351,8 +355,27 @@ function void printStdout(const char *fmt, ...) {
va_end(argList);
}
function void printlnStdout(const char *fmt, ...) {
va_list argList;
va_start(argList, fmt);
os_println(StdStream_stdout, fmt, argList);
va_end(argList);
}
void (*print)(const char *fmt, ...) = &printStdout;
#define SetStdErr() DeferLoop(print = &printStderr, print = &printStdout)
void (*println)(const char *fmt, ...) = &printlnStdout;
void setStdout() {
print = &printStdout;
println = &printlnStdout;
}
void setStderr() {
print = &printStderr;
println = &printlnStderr;
}
#define UseStderr() DeferLoop(setStderr(), setStdout())
// TODO(dledda): mat print functions
/*

9
core.h
View File

@@ -16,6 +16,9 @@
#define function static
#define global static
#define local_persist static
#define forever for (;;)
#define DeferLoop(begin_stmnt, end_stmnt) for(int __defer_i = ((begin_stmnt), 0); __defer_i < 1; (++__defer_i, (end_stmnt)))
// ### Types ###
typedef int8_t int8;
@@ -26,7 +29,7 @@ typedef uint8_t uint8;
typedef uint16_t uint16;
typedef uint32_t uint32;
typedef uint64_t uint64;
typedef uint8_t byte;
typedef char byte;
typedef float real32;
typedef double real64;
typedef struct string string;
@@ -76,6 +79,7 @@ void scratchEnd(Scratch scratch);
#define PushArrayZero(arena, type, size) (type *)pushSizeFill(arena, sizeof(type) * (size), 0)
#define PushStruct(arena, type) (type *)pushSize(arena, sizeof(type))
#define PushStructZero(arena, type) (type *)pushSizeFill(arena, sizeof(type), 0)
#define WithScratch(scratchName) Scratch scratchName; DeferLoop(scratchName = scratchStart(0, 0), scratchEnd(scratchName))
// ### Vectors ###
typedef union Vec2 Vec2;
@@ -300,7 +304,10 @@ typedef enum {
DefineList(int, Int);
void printIntList(IntList l);
void printStrList(StringList l);
void setStdout();
void setStderr();
extern void (*print)(const char *fmt, ...);
extern void (*println)(const char *fmt, ...);
// ### Loops ###
#define EachIn(list, it) size_t it = 0; it < (list).length; it++

50
os.h
View File

@@ -4,18 +4,19 @@
#include "core.h"
// ### Memory ###
void *os_alloc(size_t capacity);
void *os_alloc(uint64 capacity);
void os_reserve(void *ptr);
void os_decommit(void *ptr);
void os_free(void *ptr, size_t freeSize);
void os_free(void *ptr, uint64 freeSize);
// ### File IO ###
string os_readEntireFile(Arena *arena, string filename);
bool os_writeEntireFile(Arena *arena, string filename, const byte *contents, size_t contentsLength);
bool os_fileAppend(Arena *arena, string filename, const byte *contents, size_t contentsLength);
bool os_writeEntireFile(Arena *arena, string filename, const byte *contents, uint64 contentsLength);
bool os_fileAppend(Arena *arena, string filename, const byte *contents, uint64 contentsLength);
// ### Standard IO ###
void os_print(StdStream target, const char *fmt, va_list argList);
void os_println(StdStream target, const char *fmt, va_list argList);
// ### Multithreading ###
typedef struct OS_Thread OS_Thread;
@@ -29,23 +30,24 @@ OS_Thread os_createThread(void *(*entry)(void *ctx), void *ctx);
typedef struct Address Address;
struct Address;
typedef struct Socket Socket;
struct Socket;
typedef struct SocketHandle SocketHandle;
struct SocketHandle;
typedef struct Client Client;
struct Client {
Address *clientAddressData;
Socket *socket;
typedef struct Socket Socket;
struct Socket {
const Address *address;
SocketHandle *handle;
bool closed;
};
DefineList(Client, Client);
DefineList(Socket, Socket);
typedef struct Server Server;
struct Server {
Arena *arena;
Address *serverAddressData;
uint32 serverPort;
Socket *socket;
ClientList clients;
Address *address;
uint32 port;
SocketHandle *handle;
SocketList clients;
bool listening;
};
@@ -56,13 +58,23 @@ struct ServerInitInfo {
uint64 memory;
};
typedef struct SocketConnectInfo SocketConnectInfo;
struct SocketConnectInfo {
string address;
uint16 port;
};
// Server/Client interface
Server serverInit(ServerInitInfo info);
void serverListen(Server *s);
Client *serverAccept(Server *s);
Socket *serverAccept(Server *s);
void serverClose(Server *s);
uint64 clientRead(Client *client, void *dest, size_t bytes);
void clientWrite(Client *client);
void clientClose(Client *client);
// Generic socket interface
Socket socketConnect(Arena *arena, SocketConnectInfo info);
int64 socketRead(Socket *s, byte *dest, uint64 numBytes);
int64 socketWrite(Socket *s, byte *source, uint64 numBytes);
void socketClose(Socket *s);
#endif

107
os_linux.c
View File

@@ -10,12 +10,11 @@
#include "pthread.h"
#include "sys/socket.h"
#include "netinet/in.h"
#include "stdlib.h"
#include "arpa/inet.h"
#include "string.h" // memcpy
void *os_alloc(size_t capacity) {
void *os_alloc(uint64 capacity) {
return mmap(0, capacity, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
}
@@ -25,7 +24,7 @@ void os_commit(void *ptr) {
void os_decommit(void *ptr) {
}
void os_free(void *ptr, size_t size) {
void os_free(void *ptr, uint64 size) {
int err = munmap(ptr, size);
Assert(err != -1);
}
@@ -38,7 +37,7 @@ string os_readEntireFile(Arena *arena, string filename) {
if (input) {
struct stat st;
stat((char *)filename.str, &st);
size_t fsize = st.st_size;
uint64 fsize = st.st_size;
readBuffer = PushString(arena, fsize);
fread(readBuffer.str, sizeof(byte), readBuffer.length, input);
fclose(input);
@@ -50,7 +49,7 @@ string os_readEntireFile(Arena *arena, string filename) {
return readBuffer;
}
bool os_writeEntireFile(Arena *arena, string filename, const byte *contents, size_t contentsLength) {
bool os_writeEntireFile(Arena *arena, string filename, const byte *contents, uint64 contentsLength) {
Scratch temp = scratchStart(&arena, 1);
bool result = false;
@@ -65,7 +64,7 @@ bool os_writeEntireFile(Arena *arena, string filename, const byte *contents, siz
return result;
}
bool os_fileAppend(Arena *arena, string filename, const byte *contents, size_t contentsLength) {
bool os_fileAppend(Arena *arena, string filename, const byte *contents, uint64 contentsLength) {
Scratch temp = scratchStart(&arena, 1);
bool result = false;
@@ -80,6 +79,36 @@ bool os_fileAppend(Arena *arena, string filename, const byte *contents, size_t c
return result;
}
void os_println(StdStream target, const char *fmt, va_list argList) {
Scratch temp = scratchStart(0, 0);
uint64 origLen = calcStringLen(fmt);
string fmtLn = PushString(temp.arena, origLen + 2);
memcpy(fmtLn.str, fmt, origLen);
fmtLn.str[fmtLn.length - 2] = '\n';
fmtLn.str[fmtLn.length - 1] = '\0';
string result = strPrintfv(temp.arena, fmtLn.str, argList);
// TODO(djledda): finish implementation without cstdlib
switch (target) {
case StdStream_stdin:
write(0, (const void *)result.str, result.length);
break;
case StdStream_stderr:
fflush(stderr);
write(2, (const void *)result.str, result.length);
break;
case StdStream_stdout:
default:
fflush(stdout);
write(1, (const void *)result.str, result.length);
break;
}
scratchEnd(temp);
}
void os_print(StdStream target, const char *fmt, va_list argList) {
Scratch temp = scratchStart(0, 0);
@@ -122,14 +151,14 @@ Server serverInit(ServerInitInfo info) {
Server server = {
.arena=arena,
.serverAddressData=(Address *)serverAddr,
.clients=PushListZero(arena, ClientList, info.concurrentClients),
.address=(Address *)serverAddr,
.clients=PushListZero(arena, SocketList, info.concurrentClients),
.listening=false,
.serverPort=info.port,
.socket=(Socket *)(uint64)socket(AF_INET6, SOCK_STREAM, 0 /* IPPROTO_TCP */),
.port=info.port,
.handle=(SocketHandle *)(uint64)socket(AF_INET6, SOCK_STREAM, 0 /* IPPROTO_TCP */),
};
int bindErr = bind((int)(uint64)server.socket, (struct sockaddr *)serverAddr, sizeof(*serverAddr));
int bindErr = bind((int)(uint64)server.handle, (struct sockaddr *)serverAddr, sizeof(*serverAddr));
if (bindErr == -1) {
// TODO(dledda): handle err
}
@@ -138,48 +167,70 @@ Server serverInit(ServerInitInfo info) {
}
void serverListen(Server *s) {
int listenErr = listen((uint64)s->socket, s->clients.capacity);
int listenErr = listen((uint64)s->handle, s->clients.capacity);
if (listenErr == -1) {
// TODO(dledda): handle err
}
}
Client *serverAccept(Server *s) {
Socket *serverAccept(Server *s) {
struct sockaddr_in6 *clientAddr = PushStructZero(s->arena, struct sockaddr_in6);
socklen_t clientAddrLen = sizeof(*clientAddr);
uint64 clientSock = accept((int)(uint64)s->socket, (struct sockaddr *)clientAddr, &clientAddrLen);
uint64 clientSock = accept((int)(uint64)s->handle, (struct sockaddr *)clientAddr, &clientAddrLen);
if (clientSock == -1) {
// TODO(dledda): handle err
}
if (s->clients.length < s->clients.capacity) {
AppendList(&s->clients, ((Client){
.socket=(Socket *)(uint64)clientSock,
.clientAddressData=(Address *)clientAddr,
AppendList(&s->clients, ((Socket){
.handle=(SocketHandle *)(uint64)clientSock,
.address=(Address *)clientAddr,
}));
}
return &s->clients.data[s->clients.length - 1];
}
uint64 clientRead(Client *client, void *dest, size_t bytes) {
int bytesRead = read((uint64)client->socket, dest, bytes);
int64 socketRead(Socket *socket, byte *dest, uint64 numBytes) {
int64 bytesRead = read((uint64)socket->handle, dest, numBytes);
if (bytesRead == -1) {
// TODO(dledda): handle err
}
return bytesRead;
}
void clientWrite(Client *client) {
}
void clientClose(Client *client) {
close((int)(uint64)client->socket);
}
void serverClose(Server *s) {
close((int)(uint64)s->socket);
close((int)(uint64)s->handle);
}
void socketClose(Socket *s) {
close((int)(uint64)s->handle);
}
Socket socketConnect(Arena *arena, SocketConnectInfo info) {
int socketFd = socket(AF_INET6, SOCK_STREAM, 0 /* IPPROTO_TCP */);
struct sockaddr_in6 *remoteAddr = PushStructZero(arena, struct sockaddr_in6);
remoteAddr->sin6_family = AF_INET6;
inet_pton(AF_INET6, cstring(arena, info.address), &remoteAddr->sin6_addr);
remoteAddr->sin6_port = htons(info.port);
int connectErr = connect(socketFd, (struct sockaddr *)remoteAddr, sizeof(*remoteAddr));
Socket result = {
.handle=(SocketHandle *)(uint64)socketFd,
.address=(Address *)remoteAddr,
.closed=false,
};
if (connectErr == -1) {
// TODO(dledda): handle err
result.closed = true;
}
return result;
}
int64 socketWrite(Socket *socket, byte *source, uint64 numBytes) {
int64 written = send((uint64)socket->handle, source, numBytes, MSG_NOSIGNAL);
if (written == -1) socket->closed = true;
return written;
}
#endif