core client and server methods implemented

client.comet

@@ -0,0 +1,17 @@
+import socket
+import io
+
+func main() -> int {
+    socket.Socket s = new socket.Socket(socket.Family.INET, socket.Type.STREAM, 0)
+
+    io.println("Connecting...")
+    s.connect("127.0.0.1", 2000)
+
+    io.println("Sending data...")
+    s.send("hi!")
+
+    io.println("Closing socket...")
+    s.close()
+
+    return 0
+}

server.comet

@@ -4,10 +4,13 @@ import io
 func main() -> int {
     socket.Socket s = new socket.Socket(socket.Family.INET, socket.Type.STREAM, 0)
 
-    s.connect("142.250.188.46", 80)
+    s.bind("127.0.0.1", 2000)
-    s.send("GET / HTTP/1.1\r\nHost: google.com\r\n\r\n")
 
-    string response = s.recv(1024)
+    s.listen(10)
+    socket.Socket client = s.accept()
+    io.println("Connection received!")
+
+    string response = client.recv(256)
     io.println("Response: %s", response)
 
     s.close()

src/address.c

@@ -0,0 +1,25 @@
+#include "address.h"
+
+ResultType(int64_t, objectPtr) impl_Address_INIT(int64_t* args, CometVM* vm) {
+    CometObject* self = (CometObject*)args[0];
+
+    self->fields[0] = args[1];
+    self->fields[1] = args[2];
+
+    return Success(int64_t, objectPtr, (int64_t)self);
+}
+
+CometStruct* defineAddressStruct(CometEnvironment* env) {
+    CometStruct* addressStruct = cometDefineStruct(env, "Address", NULL);
+
+    List(StructField) fields = newList(StructField);
+    append(fields, cometCreateField("ip", cometTypeString, FIELD_PUBLIC));
+    append(fields, cometCreateField("port", cometTypeInt, FIELD_PUBLIC));
+
+    List(externalMethodPtr) methods = newList(externalMethodPtr);
+
+    cometSetStructFieldsAndMethods(addressStruct, fields, methods);
+    cometDefineConstructor(env, addressStruct, 2, false, cometTypeString, cometTypeInt);
+
+    return addressStruct;
+}

src/address.h

@@ -0,0 +1,8 @@
+#ifndef ADDRESS_H
+#define ADDRESS_H
+
+#include <comet/cometlib.h>
+
+CometStruct* defineAddressStruct(CometEnvironment* env);
+
+#endif

src/main.c

@@ -1,6 +1,8 @@
 #include <comet/cometlib.h>
 #include "socket.h"
+#include "address.h"
 
 on_import {
     defineSocketStruct(env, typeMap);
+    defineAddressStruct(env);
 }

src/socket.c

@@ -23,6 +23,16 @@ ResultType(int64_t, objectPtr) impl_Socket_INIT(int64_t* args, CometVM* vm) {
     return Success(int64_t, objectPtr, (int64_t)self);
 }
 
+struct sockaddr_in createIPV4Address(int family, char* ip, int port) {
+    struct sockaddr_in address;
+
+    inet_pton(family, ip, &address.sin_addr.s_addr);
+    address.sin_family = family;
+    address.sin_port = htons(port);
+
+    return address;
+}
+
 ResultType(int64_t, objectPtr) impl_connect(int64_t* args, CometVM* vm) {
     char* ip = cometArgString(args[0]);
     int port = cometArgInt(args[1]);
@@ -31,12 +41,7 @@ ResultType(int64_t, objectPtr) impl_connect(int64_t* args, CometVM* vm) {
     int fd = self->fields[0];
     int family = self->fields[1];
 
-    // create the address struct
+    struct sockaddr_in address = createIPV4Address(family, ip, port);
-    struct sockaddr_in address;
-
-    inet_pton(family, ip, &address.sin_addr.s_addr);
-    address.sin_family = family;
-    address.sin_port = htons(port);
 
     // then connect
     int result = connect(fd, (struct sockaddr*)&address, sizeof(address));
@@ -49,6 +54,64 @@ ResultType(int64_t, objectPtr) impl_connect(int64_t* args, CometVM* vm) {
     return Success(int64_t, objectPtr, 0);
 }
 
+ResultType(int64_t, objectPtr) impl_bind(int64_t* args, CometVM* vm) {
+    char* ip = cometArgString(args[0]);
+    int port = cometArgInt(args[1]);
+    CometObject* self = (CometObject*)args[2];
+
+    int fd = self->fields[0];
+    int family = self->fields[1];
+    
+    struct sockaddr_in address = createIPV4Address(family, ip, port);
+
+
+    int result = bind(fd, (struct sockaddr*)&address, sizeof(address));
+    if (result != 0) {
+        char* errMsg = strerror(errno);
+        return cometError(vm, "SocketError", errMsg);
+    }
+
+    return Success(int64_t, objectPtr, 0);
+}
+
+ResultType(int64_t, objectPtr) impl_listen(int64_t* args, CometVM* vm) {
+    int backlog = cometArgInt(args[0]);
+    CometObject* self = (CometObject*)args[1];
+
+    int fd = self->fields[0];
+    
+    int result = listen(fd, backlog);
+    if (result != 0) {
+        char* errMsg = strerror(errno);
+        return cometError(vm, "SocketError", errMsg);
+    }
+
+    return Success(int64_t, objectPtr, 0);
+}
+
+ResultType(int64_t, objectPtr) impl_accept(int64_t* args, CometVM* vm) {
+    CometObject* self = (CometObject*)args[0];
+
+    int fd = self->fields[0];
+
+    struct sockaddr_in clientAddr;
+    size_t clientAddrSize = sizeof(clientAddr);
+
+    int clientSocket = accept(fd, (struct sockaddr*)&clientAddr, (socklen_t*)&clientAddrSize);
+    if (clientSocket < 0) {
+        char* errMsg = strerror(errno);
+        return cometError(vm, "SocketError", errMsg);
+    }
+
+    CometSerializedStruct* socketStruct = cometVMGetStruct(vm, "Socket");
+    CometObject* clientCometSocket = cometCreateObject(socketStruct);
+
+    clientCometSocket->fields[0] = clientSocket;
+    clientCometSocket->fields[1] = clientAddr.sin_port;
+
+    return Success(int64_t, objectPtr, (int64_t)clientCometSocket);
+}
+
 ResultType(int64_t, objectPtr) impl_recv(int64_t* args, CometVM* vm) {
     int amount = cometArgInt(args[0]);
     CometObject* self = (CometObject*)args[1];
@@ -95,7 +158,7 @@ ResultType(int64_t, objectPtr) impl_close(int64_t* args, CometVM* vm) {
     int fd = self->fields[0];
 
     int result = close(fd);
-    if (result < 0) {
+    if (result != 0) {
         char* errMsg = strerror(errno);
         return cometError(vm, "IOError", errMsg);
     }
@@ -109,15 +172,30 @@ void defineSocketStruct(CometEnvironment* env, CometTypeMap* typeMap) {
 
     CometStruct* socketStruct = cometDefineStruct(env, "Socket", NULL);
 
+    CometType socketStructType = {
+        .typeKind = COMET_STRUCT,
+        .structType = socketStruct
+    };
+
     List(StructField) fields = newList(StructField);
     append(fields, cometCreateField("fd", cometTypeInt, FIELD_PRIVATE));
     append(fields, cometCreateField("family", cometTypeSmall, FIELD_READ_ONLY));
 
+    /// METHODS ///
     List(externalMethodPtr) methods = newList(externalMethodPtr);
+    // client
     append(methods, cometDefineMethod(env, "connect", socketStruct, FIELD_PUBLIC, cometTypeVoid, 2, false, cometTypeString, cometTypeInt));
+    
+    // server
+    append(methods, cometDefineMethod(env, "bind", socketStruct, FIELD_PUBLIC, cometTypeVoid, 2, false, cometTypeString, cometTypeInt));
+    append(methods, cometDefineMethod(env, "listen", socketStruct, FIELD_PUBLIC, cometTypeVoid, 1, false, cometTypeInt));
+    append(methods, cometDefineMethod(env, "accept", socketStruct, FIELD_PUBLIC, socketStructType, 0, false));
+
+    // general
     append(methods, cometDefineMethod(env, "recv", socketStruct, FIELD_PUBLIC, cometTypeString, 1, false, cometTypeInt));
     append(methods, cometDefineMethod(env, "send", socketStruct, FIELD_PUBLIC, cometTypeVoid, 1, false, cometTypeString));
     append(methods, cometDefineMethod(env, "close", socketStruct, FIELD_PUBLIC, cometTypeVoid, 0, false));
+    /// END OF METHODS ///
 
     cometSetStructFieldsAndMethods(socketStruct, fields, methods);
     cometDefineConstructor(env, socketStruct, 3, false, familyEnum, typeEnum, cometTypeInt);