initial progress on modems

build.zig

@@ -38,6 +38,7 @@ fn addEngineSources(b: *std.Build, opts: LibBuildOpts) *std.Build.Module {
             "src/components/screen.c",
             "src/components/gpu.c",
             "src/components/keyboard.c",
+            "src/components/modem.c",
         },
         .flags = &.{
             if(opts.baremetal) "-DNN_BAREMETAL" else "",

src/components/modem.c

@@ -0,0 +1,55 @@
+#include "../neonucleus.h"
+
+typedef struct nn_modem {
+    nn_Context ctx;
+    nn_guard *lock;
+    nn_refc refc;
+    nn_modemTable table;
+    nn_networkControl ctrl;
+} nn_modem;
+
+nn_modem *nn_newModem(nn_Context *context, nn_modemTable table, nn_networkControl control) {
+    nn_modem *m = nn_alloc(&context->allocator, sizeof(nn_modem));
+    if(m == NULL) return m;
+    m->ctx = *context;
+    m->lock = nn_newGuard(context);
+    m->refc = 1;
+    m->table = table;
+    m->ctrl = control;
+    return m;
+}
+
+nn_guard *nn_getModemLock(nn_modem *modem) {
+    return modem->lock;
+}
+
+void nn_retainModem(nn_modem *modem) {
+    nn_incRef(&modem->refc);
+}
+
+nn_bool_t nn_destroyModem(nn_modem *modem) {
+    if(!nn_decRef(&modem->refc)) return false;
+
+    if(modem->table.deinit != NULL) {
+        modem->table.deinit(modem->table.userdata);
+    }
+
+    nn_Context ctx = modem->ctx;
+    nn_deleteGuard(&ctx, modem->lock);
+    nn_dealloc(&ctx.allocator, modem, sizeof(nn_modem));
+    return true;
+}
+
+void nn_modem_destroy(void *_, nn_component *component, nn_modem *modem) {
+    nn_destroyModem(modem);
+}
+
+void nn_loadModemTable(nn_universe *universe) {
+    nn_componentTable *modemTable = nn_newComponentTable(nn_getAllocator(universe), "modem", NULL, NULL, (nn_componentDestructor *)nn_modem_destroy);
+    nn_storeUserdata(universe, "NN:MODEM", modemTable);
+}
+
+nn_component *nn_addModem(nn_computer *computer, nn_address address, int slot, nn_modem *modem) {
+    nn_componentTable *modemTable = nn_queryUserdata(nn_getUniverse(computer), "NN:MODEM");
+    return nn_newComponent(computer, address, slot, modemTable, modem);
+}

src/computer.c

@@ -524,6 +524,18 @@ nn_value nn_return_table(nn_computer *computer, nn_size_t len) {
     return val;
 }
 
+nn_bool_t nn_wakeupMatches(nn_value *values, nn_size_t valueLen, const char *wakeUp, nn_bool_t fuzzy) {
+    if(valueLen == 0) return false;
+    nn_value header = values[0];
+    const char *headerStr = nn_toCString(header);
+
+    if(fuzzy) {
+        return nn_strbegin(headerStr, wakeUp);
+    } else {
+        return nn_strcmp(headerStr, wakeUp) == 0;
+    }
+}
+
 const char *nn_pushNetworkMessage(nn_computer *computer, nn_address receiver, nn_address sender, nn_size_t port, double distance, nn_value *values, nn_size_t valueLen) {
     nn_Alloc *alloc = &computer->universe->ctx.allocator;
 

src/neonucleus.h

@@ -609,6 +609,8 @@ void nn_loadDriveTable(nn_universe *universe);
 void nn_loadScreenTable(nn_universe *universe);
 void nn_loadGraphicsCardTable(nn_universe *universe);
 void nn_loadKeyboardTable(nn_universe *universe);
+void nn_loadModemTable(nn_universe *universe);
+void nn_loadTunnelTable(nn_universe *universe);
 
 nn_component *nn_mountKeyboard(nn_computer *computer, nn_address address, int slot);
 
@@ -897,7 +899,10 @@ typedef struct nn_networkControl {
     double energyPerFullPacket;
 } nn_networkControl;
 
+nn_bool_t nn_wakeupMatches(nn_value *values, nn_size_t valueLen, const char *wakeUp, nn_bool_t fuzzy);
+
 // NULL on success, error string on failure
+// this *retains* all of those values, meaning you must drop them after call this function
 const char *nn_pushNetworkMessage(nn_computer *computer, nn_address receiver, nn_address sender, nn_size_t port, double distance, nn_value *values, nn_size_t valueLen);
 
 typedef struct nn_modemTable {
@@ -909,23 +914,24 @@ typedef struct nn_modemTable {
     nn_bool_t wireless;
     nn_size_t maxValues;
     nn_size_t maxPacketSize;
+    nn_size_t maxOpenPorts;
 
     // ports
 
-    nn_bool_t (*isOpen)(void *userdata, nn_size_t port);
+    nn_bool_t (*isOpen)(void *userdata, nn_size_t port, nn_errorbuf_t err);
-    nn_bool_t (*open)(void *userdata, nn_size_t port);
+    nn_bool_t (*open)(void *userdata, nn_size_t port, nn_errorbuf_t err);
-    // port 0 means close all
+    // port NN_TUNNEL_PORT means close all
-    nn_bool_t (*close)(void *userdata, nn_size_t port);
+    nn_bool_t (*close)(void *userdata, nn_size_t port, nn_errorbuf_t err);
     
     // messages
 
     // Address is NULL if broadcasting
-    nn_bool_t (*send)(void *userdata, nn_address address, nn_size_t port, nn_value *values, nn_size_t valueCount);
+    nn_bool_t (*send)(void *userdata, nn_address address, nn_size_t port, nn_value *values, nn_size_t valueCount, nn_errorbuf_t err);
 
     // signal strength
     nn_size_t maxStrength;
-    nn_size_t (*getStrength)(void *userdata);
+    nn_size_t (*getStrength)(void *userdata, nn_errorbuf_t err);
-    nn_bool_t (*setStrength)(void *userdata, nn_size_t strength);
+    nn_bool_t (*setStrength)(void *userdata, nn_size_t strength, nn_errorbuf_t err);
 
     // wake message
     void (*getWakeMessage)(void *userdata, char *buf, nn_size_t *buflen);
@@ -948,6 +954,8 @@ nn_guard *nn_getModemLock(nn_modem *modem);
 void nn_retainModem(nn_modem *modem);
 nn_bool_t nn_destroyModem(nn_modem *modem);
 
+nn_component *nn_addModem(nn_computer *computer, nn_address address, int slot, nn_modem *modem);
+
 typedef struct nn_tunnelTable {
     void *userdata;
     void (*deinit)(void *userdata);
@@ -969,6 +977,8 @@ nn_guard *nn_getTunnelLock(nn_tunnel *tunnel);
 void nn_retainTunnel(nn_tunnel *tunnel);
 nn_bool_t nn_destroyTunnel(nn_tunnel *tunnel);
 
+nn_component *nn_addTunnel(nn_computer *computer, nn_address address, int slot, nn_tunnel *modem);
+
 #ifdef __cplusplus
 }
 #endif

src/universe.c

@@ -53,4 +53,5 @@ void nn_loadCoreComponentTables(nn_universe *universe) {
     nn_loadScreenTable(universe);
     nn_loadGraphicsCardTable(universe);
     nn_loadKeyboardTable(universe);
+    nn_loadModemTable(universe);
 }