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

79
app.c
View File

@@ -2,29 +2,49 @@
#include "core.c" #include "core.c"
#include "signal.h" #include "signal.h"
#include "stdlib.h"
Server *server = NULL; Server *server = NULL;
void handleSigint(int dummy) { void handleSigint(int dummy) {
if (server) { if (server) {
print("\n"); println("");
print("Closing server socket.\n"); println("Closing server socket.");
serverClose(server); serverClose(server);
print("Success\n."); println("Success.");
} }
exit(0); signal(SIGINT, SIG_DFL);
raise(SIGINT);
} }
int djstd_entry(Arena *arena, StringList args) { int djstd_entry(Arena *arena, StringList args) {
signal(SIGINT, &handleSigint); 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; int port = 8080;
Int32Result portParsed = parsePositiveInt(args.data[0]); Int32Result portParsed = parsePositiveInt(args.data[1]);
if (portParsed.valid) { if (portParsed.valid) {
port = portParsed.result; port = portParsed.result;
} }
print("Starting server on port %d\n", port); 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){ Server myserver = serverInit((ServerInitInfo){
.concurrentClients=16, .concurrentClients=16,
.port=port, .port=port,
@@ -34,19 +54,50 @@ int djstd_entry(Arena *arena, StringList args) {
server = &myserver; server = &myserver;
serverListen(&myserver); serverListen(&myserver);
Client *client = serverAccept(&myserver); Socket *client = serverAccept(&myserver);
CharList buf = PushFullListZero(arena, CharList, 257); forever {
uint64 bytesRead = clientRead(client, (void *)buf.data, buf.length - 1); string buf = PushStringFill(arena, 256, 0);
uint64 bytesRead = socketRead(client, buf.str, buf.length - 1);
if (bytesRead > 0) { if (bytesRead > 0) {
print("Client said: %s\n", buf.data); buf.length = bytesRead;
print("Now that's insightful.\n"); println("Client said: %S", strSplit(arena, s("\n"), buf).data[0]);
} else if (bytesRead == -1) {
print("Connection error\n"); println("Saying goodbye");
string message = s("Goodbye\n");
socketWrite(client, message.str, message.length);
break;
}
serverClose(&myserver);
} }
clientClose(client); 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; return 0;
} }

37
core.c
View File

@@ -71,9 +71,6 @@ Scratch scratchStart(Arena **conflicts, size_t conflictCount) {
return scratch; 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) { void scratchEnd(Scratch scratch) {
arenaFreeFrom(scratch.arena, scratch.start); arenaFreeFrom(scratch.arena, scratch.start);
} }
@@ -206,8 +203,8 @@ StringList strSplit(Arena *arena, string splitStr, string inputStr) {
size_t splitCount = 0; size_t splitCount = 0;
size_t c = 0; size_t c = 0;
size_t start = 0; size_t start = 0;
void *beginning = (char *)arena->memory + arena->head; void *beginning = arena->memory + arena->head;
while (c < inputStr.length - splitStr.length) { while (c < inputStr.length) {
string mystr = strSlice(inputStr, c, c + splitStr.length); string mystr = strSlice(inputStr, c, c + splitStr.length);
if (strEql(mystr, splitStr)) { if (strEql(mystr, splitStr)) {
string *splitString = PushStruct(arena, string); string *splitString = PushStruct(arena, string);
@@ -337,13 +334,20 @@ string formatTimeYmd(Arena *arena, Timestamp *time) {
return buf; return buf;
} }
void printStderr(const char *fmt, ...) { function void printStderr(const char *fmt, ...) {
va_list argList; va_list argList;
va_start(argList, fmt); va_start(argList, fmt);
os_print(StdStream_stdout, fmt, argList); os_print(StdStream_stdout, fmt, argList);
va_end(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, ...) { function void printStdout(const char *fmt, ...) {
va_list argList; va_list argList;
va_start(argList, fmt); va_start(argList, fmt);
@@ -351,8 +355,27 @@ function void printStdout(const char *fmt, ...) {
va_end(argList); 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; 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 // TODO(dledda): mat print functions
/* /*

9
core.h
View File

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

50
os.h
View File

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

107
os_linux.c
View File

@@ -10,12 +10,11 @@
#include "pthread.h" #include "pthread.h"
#include "sys/socket.h" #include "sys/socket.h"
#include "netinet/in.h"
#include "stdlib.h"
#include "arpa/inet.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); 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_decommit(void *ptr) {
} }
void os_free(void *ptr, size_t size) { void os_free(void *ptr, uint64 size) {
int err = munmap(ptr, size); int err = munmap(ptr, size);
Assert(err != -1); Assert(err != -1);
} }
@@ -38,7 +37,7 @@ string os_readEntireFile(Arena *arena, string filename) {
if (input) { if (input) {
struct stat st; struct stat st;
stat((char *)filename.str, &st); stat((char *)filename.str, &st);
size_t fsize = st.st_size; uint64 fsize = st.st_size;
readBuffer = PushString(arena, fsize); readBuffer = PushString(arena, fsize);
fread(readBuffer.str, sizeof(byte), readBuffer.length, input); fread(readBuffer.str, sizeof(byte), readBuffer.length, input);
fclose(input); fclose(input);
@@ -50,7 +49,7 @@ string os_readEntireFile(Arena *arena, string filename) {
return readBuffer; 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); Scratch temp = scratchStart(&arena, 1);
bool result = false; bool result = false;
@@ -65,7 +64,7 @@ bool os_writeEntireFile(Arena *arena, string filename, const byte *contents, siz
return result; 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); Scratch temp = scratchStart(&arena, 1);
bool result = false; bool result = false;
@@ -80,6 +79,36 @@ bool os_fileAppend(Arena *arena, string filename, const byte *contents, size_t c
return result; 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) { void os_print(StdStream target, const char *fmt, va_list argList) {
Scratch temp = scratchStart(0, 0); Scratch temp = scratchStart(0, 0);
@@ -122,14 +151,14 @@ Server serverInit(ServerInitInfo info) {
Server server = { Server server = {
.arena=arena, .arena=arena,
.serverAddressData=(Address *)serverAddr, .address=(Address *)serverAddr,
.clients=PushListZero(arena, ClientList, info.concurrentClients), .clients=PushListZero(arena, SocketList, info.concurrentClients),
.listening=false, .listening=false,
.serverPort=info.port, .port=info.port,
.socket=(Socket *)(uint64)socket(AF_INET6, SOCK_STREAM, 0 /* IPPROTO_TCP */), .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) { if (bindErr == -1) {
// TODO(dledda): handle err // TODO(dledda): handle err
} }
@@ -138,48 +167,70 @@ Server serverInit(ServerInitInfo info) {
} }
void serverListen(Server *s) { 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) { if (listenErr == -1) {
// TODO(dledda): handle err // TODO(dledda): handle err
} }
} }
Client *serverAccept(Server *s) { Socket *serverAccept(Server *s) {
struct sockaddr_in6 *clientAddr = PushStructZero(s->arena, struct sockaddr_in6); struct sockaddr_in6 *clientAddr = PushStructZero(s->arena, struct sockaddr_in6);
socklen_t clientAddrLen = sizeof(*clientAddr); 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) { if (clientSock == -1) {
// TODO(dledda): handle err // TODO(dledda): handle err
} }
if (s->clients.length < s->clients.capacity) { if (s->clients.length < s->clients.capacity) {
AppendList(&s->clients, ((Client){ AppendList(&s->clients, ((Socket){
.socket=(Socket *)(uint64)clientSock, .handle=(SocketHandle *)(uint64)clientSock,
.clientAddressData=(Address *)clientAddr, .address=(Address *)clientAddr,
})); }));
} }
return &s->clients.data[s->clients.length - 1]; return &s->clients.data[s->clients.length - 1];
} }
uint64 clientRead(Client *client, void *dest, size_t bytes) { int64 socketRead(Socket *socket, byte *dest, uint64 numBytes) {
int bytesRead = read((uint64)client->socket, dest, bytes); int64 bytesRead = read((uint64)socket->handle, dest, numBytes);
if (bytesRead == -1) { if (bytesRead == -1) {
// TODO(dledda): handle err // TODO(dledda): handle err
} }
return bytesRead; return bytesRead;
} }
void clientWrite(Client *client) {
}
void clientClose(Client *client) {
close((int)(uint64)client->socket);
}
void serverClose(Server *s) { 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 #endif