wip

This is a preliminary step necessary to move the server to a separate
thread.

app/src/events.h

@@ -1,2 +1,4 @@
-#define EVENT_NEW_FRAME       SDL_USEREVENT
-#define EVENT_STREAM_STOPPED (SDL_USEREVENT + 1)
+#define EVENT_NEW_FRAME                 SDL_USEREVENT
+#define EVENT_STREAM_STOPPED           (SDL_USEREVENT + 1)
+#define EVENT_SERVER_CONNECTION_FAILED (SDL_USEREVENT + 2)
+#define EVENT_SERVER_CONNECTED         (SDL_USEREVENT + 3)

app/src/scrcpy.c

@@ -217,6 +217,29 @@ event_loop(struct scrcpy *s, const struct scrcpy_options *options) {
     return false;
 }
 
+static bool
+await_for_server(void) {
+    SDL_Event event;
+    while (SDL_WaitEvent(&event)) {
+        switch (event.type) {
+            case SDL_QUIT:
+                LOGD("User requested to quit");
+                return false;
+            case EVENT_SERVER_CONNECTION_FAILED:
+                LOGE("Server connection failed");
+                return false;
+            case EVENT_SERVER_CONNECTED:
+                LOGD("Server connected");
+                return true;
+            default:
+                break;
+        }
+    }
+
+    LOGE("SDL_WaitEvent() error: %s", SDL_GetError());
+    return false;
+}
+
 static SDL_LogPriority
 sdl_priority_from_av_level(int level) {
     switch (level) {
@@ -262,6 +285,31 @@ stream_on_eos(struct stream *stream, void *userdata) {
     PUSH_EVENT(EVENT_STREAM_STOPPED);
 }
 
+static void
+server_on_connection_failed(struct server *server, void *userdata) {
+    (void) server;
+    (void) userdata;
+
+    PUSH_EVENT(EVENT_SERVER_CONNECTION_FAILED);
+}
+
+static void
+server_on_connected(struct server *server, void *userdata) {
+    (void) server;
+    (void) userdata;
+
+    PUSH_EVENT(EVENT_SERVER_CONNECTED);
+}
+
+static void
+server_on_disconnected(struct server *server, void *userdata) {
+    (void) server;
+    (void) userdata;
+
+    LOGD("Server disconnected");
+    // Do nothing, will be managed by the "stream stopped" event
+}
+
 bool
 scrcpy(struct scrcpy_options *options) {
     static struct scrcpy scrcpy;
@@ -275,10 +323,6 @@ scrcpy(struct scrcpy_options *options) {
 
     atexit(SDL_Quit);
 
-    if (!server_init(&s->server)) {
-        return false;
-    }
-
     bool ret = false;
 
     bool server_started = false;
@@ -313,7 +357,17 @@ scrcpy(struct scrcpy_options *options) {
         .force_adb_forward = options->force_adb_forward,
         .power_off_on_close = options->power_off_on_close,
     };
-    if (!server_start(&s->server, &params)) {
+
+    static const struct server_callbacks cbs = {
+        .on_connection_failed = server_on_connection_failed,
+        .on_connected = server_on_connected,
+        .on_disconnected = server_on_disconnected,
+    };
+    if (!server_init(&s->server, &params, &cbs, NULL)) {
+        return false;
+    }
+
+    if (!server_start(&s->server)) {
         goto end;
     }
 
@@ -331,15 +385,15 @@ scrcpy(struct scrcpy_options *options) {
 
     sdl_configure(options->display, options->disable_screensaver);
 
-    char device_name[DEVICE_NAME_FIELD_LENGTH];
-    struct sc_size frame_size;
-
-    if (!server_connect_to(&s->server, device_name, &frame_size)) {
+    // Await for server without blocking Ctrl+C handling
+    if (!await_for_server()) {
         goto end;
     }
 
+    struct server_info *info = &s->server.info;
+
     if (options->display && options->control) {
-        if (!file_handler_init(&s->file_handler, s->server.serial,
+        if (!file_handler_init(&s->file_handler, options->serial,
                                options->push_target)) {
             goto end;
         }
@@ -361,7 +415,7 @@ scrcpy(struct scrcpy_options *options) {
         if (!recorder_init(&s->recorder,
                            options->record_filename,
                            options->record_format,
-                           frame_size)) {
+                           info->frame_size)) {
             goto end;
         }
         rec = &s->recorder;
@@ -407,11 +461,11 @@ scrcpy(struct scrcpy_options *options) {
 
     if (options->display) {
         const char *window_title =
-            options->window_title ? options->window_title : device_name;
+            options->window_title ? options->window_title : info->device_name;
 
         struct screen_params screen_params = {
             .window_title = window_title,
-            .frame_size = frame_size,
+            .frame_size = info->frame_size,
             .always_on_top = options->always_on_top,
             .window_x = options->window_x,
             .window_y = options->window_y,
@@ -434,8 +488,8 @@ scrcpy(struct scrcpy_options *options) {
 
 #ifdef HAVE_V4L2
     if (options->v4l2_device) {
-        if (!sc_v4l2_sink_init(&s->v4l2_sink, options->v4l2_device, frame_size,
-                               options->v4l2_buffer)) {
+        if (!sc_v4l2_sink_init(&s->v4l2_sink, options->v4l2_device,
+                               info->frame_size, options->v4l2_buffer)) {
             goto end;
         }
 

app/src/server.c

@@ -61,6 +61,44 @@ get_server_path(void) {
     return server_path;
 }
 
+static void
+server_params_destroy(struct server_params *params) {
+    // The server stores a copy of the params provided by the user
+    free((char *) params->serial);
+    free((char *) params->crop);
+    free((char *) params->codec_options);
+    free((char *) params->encoder_name);
+}
+
+static bool
+server_params_copy(struct server_params *dst, const struct server_params *src) {
+    *dst = *src;
+
+    // The params reference user-allocated memory, so we must copy them to
+    // handle them from another thread
+
+#define COPY(FIELD) \
+    dst->FIELD = NULL; \
+    if (src->FIELD) { \
+        dst->FIELD = strdup(src->FIELD); \
+        if (!dst->FIELD) { \
+            goto error; \
+        } \
+    }
+
+    COPY(serial);
+    COPY(crop);
+    COPY(codec_options);
+    COPY(encoder_name);
+#undef COPY
+
+    return true;
+
+error:
+    server_params_destroy(dst);
+    return false;
+}
+
 static bool
 push_server(const char *serial) {
     char *server_path = get_server_path();
@@ -103,24 +141,26 @@ disable_tunnel_forward(const char *serial, uint16_t local_port) {
 
 static bool
 disable_tunnel(struct server *server) {
+    const char *serial = server->params.serial;
     if (server->tunnel_forward) {
-        return disable_tunnel_forward(server->serial, server->local_port);
+        return disable_tunnel_forward(serial, server->local_port);
     }
-    return disable_tunnel_reverse(server->serial);
+    return disable_tunnel_reverse(serial);
 }
 
-static sc_socket
-listen_on_port(uint16_t port) {
+static bool
+listen_on_port(sc_socket socket, uint16_t port) {
 #define IPV4_LOCALHOST 0x7F000001
-    return net_listen(IPV4_LOCALHOST, port, 1);
+    return net_listen(socket, IPV4_LOCALHOST, port, 1);
 }
 
 static bool
 enable_tunnel_reverse_any_port(struct server *server,
                                struct sc_port_range port_range) {
+    const char *serial = server->params.serial;
     uint16_t port = port_range.first;
     for (;;) {
-        if (!enable_tunnel_reverse(server->serial, port)) {
+        if (!enable_tunnel_reverse(serial, port)) {
             // the command itself failed, it will fail on any port
             return false;
         }
@@ -131,15 +171,21 @@ enable_tunnel_reverse_any_port(struct server *server,
         // client can listen before starting the server app, so there is no
         // need to try to connect until the server socket is listening on the
         // device.
-        server->server_socket = listen_on_port(port);
-        if (server->server_socket != SC_INVALID_SOCKET) {
-            // success
-            server->local_port = port;
-            return true;
+        sc_socket server_socket = net_socket();
+        if (server_socket != SC_INVALID_SOCKET) {
+            bool ok = listen_on_port(server_socket, port);
+            if (ok) {
+                // success
+                server->server_socket = server_socket;
+                server->local_port = port;
+                return true;
+            }
+
+            net_close(server_socket);
         }
 
         // failure, disable tunnel and try another port
-        if (!disable_tunnel_reverse(server->serial)) {
+        if (!disable_tunnel_reverse(serial)) {
             LOGW("Could not remove reverse tunnel on port %" PRIu16, port);
         }
 
@@ -165,9 +211,11 @@ static bool
 enable_tunnel_forward_any_port(struct server *server,
                                struct sc_port_range port_range) {
     server->tunnel_forward = true;
+
+    const char *serial = server->params.serial;
     uint16_t port = port_range.first;
     for (;;) {
-        if (enable_tunnel_forward(server->serial, port)) {
+        if (enable_tunnel_forward(serial, port)) {
             // success
             server->local_port = port;
             return true;
@@ -229,6 +277,8 @@ log_level_to_server_string(enum sc_log_level level) {
 
 static process_t
 execute_server(struct server *server, const struct server_params *params) {
+    const char *serial = server->params.serial;
+
     char max_size_string[6];
     char bit_rate_string[11];
     char max_fps_string[6];
@@ -286,16 +336,22 @@ execute_server(struct server *server, const struct server_params *params) {
     //     Port: 5005
     // Then click on "Debug"
 #endif
-    return adb_execute(server->serial, cmd, ARRAY_LEN(cmd));
+    return adb_execute(serial, cmd, ARRAY_LEN(cmd));
 }
 
 static sc_socket
 connect_and_read_byte(uint16_t port) {
-    sc_socket socket = net_connect(IPV4_LOCALHOST, port);
+    sc_socket socket = net_socket();
     if (socket == SC_INVALID_SOCKET) {
         return SC_INVALID_SOCKET;
     }
 
+    bool ok = net_connect(socket, IPV4_LOCALHOST, port);
+    if (!ok) {
+        net_close(socket);
+        return SC_INVALID_SOCKET;
+    }
+
     char byte;
     // the connection may succeed even if the server behind the "adb tunnel"
     // is not listening, so read one byte to detect a working connection
@@ -308,7 +364,8 @@ connect_and_read_byte(uint16_t port) {
 }
 
 static sc_socket
-connect_to_server(uint16_t port, uint32_t attempts, uint32_t delay) {
+connect_to_server(struct server *server, uint32_t attempts, sc_tick delay) {
+    uint16_t port = server->local_port;
     do {
         LOGD("Remaining connection attempts: %d", (int) attempts);
         sc_socket socket = connect_and_read_byte(port);
@@ -317,29 +374,56 @@ connect_to_server(uint16_t port, uint32_t attempts, uint32_t delay) {
             return socket;
         }
         if (attempts) {
-            SDL_Delay(delay);
+            sc_mutex_lock(&server->mutex);
+            // Ignore timedwait return (spurious wake ups are harmless)
+            sc_cond_timedwait(&server->stopped_cond, &server->mutex,
+                              sc_tick_now() + delay);
+            bool stopped = server->stopped;
+            sc_mutex_unlock(&server->mutex);
+            if (stopped) {
+                LOGI("Connection attempt stopped");
+                break;
+            }
         }
     } while (--attempts > 0);
     return SC_INVALID_SOCKET;
 }
 
 bool
-server_init(struct server *server) {
-    server->serial = NULL;
+server_init(struct server *server, const struct server_params *params,
+            const struct server_callbacks *cbs, void *cbs_userdata) {
+    bool ok = server_params_copy(&server->params, params);
+    if (!ok) {
+        LOGE("Could not copy server params");
+        return false;
+    }
+
     server->process = PROCESS_NONE;
 
-    bool ok = sc_mutex_init(&server->mutex);
+    ok = sc_mutex_init(&server->mutex);
     if (!ok) {
+        server_params_destroy(&server->params);
         return false;
     }
 
     ok = sc_cond_init(&server->process_terminated_cond);
     if (!ok) {
         sc_mutex_destroy(&server->mutex);
+        server_params_destroy(&server->params);
+        return false;
+    }
+
+    ok = sc_cond_init(&server->stopped_cond);
+    if (!ok) {
+        sc_cond_destroy(&server->process_terminated_cond);
+        sc_mutex_destroy(&server->mutex);
+        server_params_destroy(&server->params);
         return false;
     }
 
     server->process_terminated = false;
+    server->stopped = false;
+    server->connected = false;
 
     server->server_socket = SC_INVALID_SOCKET;
     server->video_socket = SC_INVALID_SOCKET;
@@ -350,13 +434,69 @@ server_init(struct server *server) {
     server->tunnel_enabled = false;
     server->tunnel_forward = false;
 
+    assert(cbs);
+    assert(cbs->on_connection_failed);
+    assert(cbs->on_connected);
+    assert(cbs->on_disconnected);
+
+    server->cbs = cbs;
+    server->cbs_userdata = cbs_userdata;
+
     return true;
 }
 
 static int
-run_wait_server(void *data) {
+run_server_connect(void *data) {
     struct server *server = data;
+
+    if (!server_connect_to(server, &server->info)) {
+        server->cbs->on_connection_failed(server, server->cbs_userdata);
+        goto end;
+    }
+
+    server->connected = true;
+    server->cbs->on_connected(server, server->cbs_userdata);
+
+end:
+    return 0;
+}
+
+static int
+run_server(void *data) {
+    struct server *server = data;
+
+    const struct server_params *params = &server->params;
+
+    if (!push_server(params->serial)) {
+        server->cbs->on_connection_failed(server, server->cbs_userdata);
+        goto end;
+    }
+
+    if (!enable_tunnel_any_port(server, params->port_range,
+                                params->force_adb_forward)) {
+        server->cbs->on_connection_failed(server, server->cbs_userdata);
+        goto end;
+    }
+
+    server->process = execute_server(server, params);
+    if (server->process == PROCESS_NONE) {
+        server->cbs->on_connection_failed(server, server->cbs_userdata);
+        goto end;
+    }
+
+    sc_thread connect_thread;
+    bool ok = sc_thread_create(&connect_thread, run_server_connect,
+                               "server-connect", server);
+    if (!ok) {
+        LOGW("Could not create thread, killing the server...");
+        process_terminate(server->process);
+        server->cbs->on_connection_failed(server, server->cbs_userdata);
+        process_wait(server->process, false); // ignore exit code
+        goto end;
+    }
+
     process_wait(server->process, false); // ignore exit code
+    LOGD("Server terminated");
 
     sc_mutex_lock(&server->mutex);
     server->process_terminated = true;
@@ -370,64 +510,26 @@ run_wait_server(void *data) {
         net_interrupt(server->server_socket);
     }
 
-    LOGD("Server terminated");
+    sc_thread_join(&connect_thread, NULL);
+
+    // Written by connect_thread, sc_thread_join() provides the necessary
+    // memory barrier
+    if (server->connected) {
+        server->cbs->on_disconnected(server, server->cbs_userdata);
+    }
+    // Otherwise, ->on_connection_failed() is already called
+
+end:
     return 0;
 }
 
 bool
-server_start(struct server *server, const struct server_params *params) {
-    if (params->serial) {
-        server->serial = strdup(params->serial);
-        if (!server->serial) {
-            return false;
-        }
-    }
-
-    if (!push_server(params->serial)) {
-        /* server->serial will be freed on server_destroy() */
-        return false;
-    }
-
-    if (!enable_tunnel_any_port(server, params->port_range,
-                                params->force_adb_forward)) {
-        return false;
-    }
-
-    // server will connect to our server socket
-    server->process = execute_server(server, params);
-    if (server->process == PROCESS_NONE) {
-        goto error;
-    }
-
-    // If the server process dies before connecting to the server socket, then
-    // the client will be stuck forever on accept(). To avoid the problem, we
-    // must be able to wake up the accept() call when the server dies. To keep
-    // things simple and multiplatform, just spawn a new thread waiting for the
-    // server process and calling shutdown()/close() on the server socket if
-    // necessary to wake up any accept() blocking call.
-    bool ok = sc_thread_create(&server->wait_server_thread, run_wait_server,
-                               "wait-server", server);
-    if (!ok) {
-        process_terminate(server->process);
-        process_wait(server->process, true); // ignore exit code
-        goto error;
-    }
-
-    server->tunnel_enabled = true;
-
-    return true;
-
-error:
-    // The server socket (if any) will be closed on server_destroy()
-
-    disable_tunnel(server);
-
-    return false;
+server_start(struct server *server) {
+    return sc_thread_create(&server->thread, run_server, "server", server);
 }
 
 static bool
-device_read_info(sc_socket device_socket, char *device_name,
-                 struct sc_size *size) {
+device_read_info(sc_socket device_socket, struct server_info *info) {
     unsigned char buf[DEVICE_NAME_FIELD_LENGTH + 4];
     ssize_t r = net_recv_all(device_socket, buf, sizeof(buf));
     if (r < DEVICE_NAME_FIELD_LENGTH + 4) {
@@ -436,19 +538,17 @@ device_read_info(sc_socket device_socket, char *device_name,
     }
     // in case the client sends garbage
     buf[DEVICE_NAME_FIELD_LENGTH - 1] = '\0';
-    // strcpy is safe here, since name contains at least
-    // DEVICE_NAME_FIELD_LENGTH bytes and strlen(buf) < DEVICE_NAME_FIELD_LENGTH
-    strcpy(device_name, (char *) buf);
-    size->width = (buf[DEVICE_NAME_FIELD_LENGTH] << 8)
-            | buf[DEVICE_NAME_FIELD_LENGTH + 1];
-    size->height = (buf[DEVICE_NAME_FIELD_LENGTH + 2] << 8)
-            | buf[DEVICE_NAME_FIELD_LENGTH + 3];
+    memcpy(info->device_name, (char *) buf, sizeof(info->device_name));
+
+    info->frame_size.width = (buf[DEVICE_NAME_FIELD_LENGTH] << 8)
+                           | buf[DEVICE_NAME_FIELD_LENGTH + 1];
+    info->frame_size.height = (buf[DEVICE_NAME_FIELD_LENGTH + 2] << 8)
+                            | buf[DEVICE_NAME_FIELD_LENGTH + 3];
     return true;
 }
 
 bool
-server_connect_to(struct server *server, char *device_name,
-                  struct sc_size *size) {
+server_connect_to(struct server *server, struct server_info *info) {
     if (!server->tunnel_forward) {
         server->video_socket = net_accept(server->server_socket);
         if (server->video_socket == SC_INVALID_SOCKET) {
@@ -469,19 +569,23 @@ server_connect_to(struct server *server, char *device_name,
         server->server_socket = SC_INVALID_SOCKET;
     } else {
         uint32_t attempts = 100;
-        uint32_t delay = 100; // ms
-        server->video_socket =
-            connect_to_server(server->local_port, attempts, delay);
+        sc_tick delay = SC_TICK_FROM_MS(100);
+        server->video_socket = connect_to_server(server, attempts, delay);
         if (server->video_socket == SC_INVALID_SOCKET) {
             return false;
         }
 
         // we know that the device is listening, we don't need several attempts
-        server->control_socket =
-            net_connect(IPV4_LOCALHOST, server->local_port);
+        server->control_socket = net_socket();
         if (server->control_socket == SC_INVALID_SOCKET) {
             return false;
         }
+        bool ok = net_connect(server->control_socket, IPV4_LOCALHOST,
+                              server->local_port);
+        if (!ok) {
+            net_close(server->control_socket);
+            return false;
+        }
     }
 
     // we don't need the adb tunnel anymore
@@ -489,11 +593,16 @@ server_connect_to(struct server *server, char *device_name,
     server->tunnel_enabled = false;
 
     // The sockets will be closed on stop if device_read_info() fails
-    return device_read_info(server->video_socket, device_name, size);
+    return device_read_info(server->video_socket, info);
 }
 
 void
 server_stop(struct server *server) {
+    sc_mutex_lock(&server->mutex);
+    server->stopped = true;
+    sc_cond_signal(&server->stopped_cond);
+    sc_mutex_unlock(&server->mutex);
+
     if (server->server_socket != SC_INVALID_SOCKET) {
         if (!net_interrupt(server->server_socket)) {
             LOGW("Could not interrupt server socket");
@@ -538,7 +647,7 @@ server_stop(struct server *server) {
         process_terminate(server->process);
     }
 
-    sc_thread_join(&server->wait_server_thread, NULL);
+    sc_thread_join(&server->thread, NULL);
     process_close(server->process);
 }
 
@@ -559,7 +668,9 @@ server_destroy(struct server *server) {
             LOGW("Could not close control socket");
         }
     }
-    free(server->serial);
+
+    server_params_destroy(&server->params);
+    sc_cond_destroy(&server->stopped_cond);
     sc_cond_destroy(&server->process_terminated_cond);
     sc_mutex_destroy(&server->mutex);
 }

app/src/server.h

@@ -14,21 +14,10 @@
 #include "util/net.h"
 #include "util/thread.h"
 
-struct server {
-    char *serial;
-    process_t process;
-    sc_thread wait_server_thread;
-
-    sc_mutex mutex;
-    sc_cond process_terminated_cond;
-    bool process_terminated;
-
-    sc_socket server_socket; // only used if !tunnel_forward
-    sc_socket video_socket;
-    sc_socket control_socket;
-    uint16_t local_port; // selected from port_range
-    bool tunnel_enabled;
-    bool tunnel_forward; // use "adb forward" instead of "adb reverse"
+#define DEVICE_NAME_FIELD_LENGTH 64
+struct server_info {
+    char device_name[DEVICE_NAME_FIELD_LENGTH];
+    struct sc_size frame_size;
 };
 
 struct server_params {
@@ -50,20 +39,54 @@ struct server_params {
     bool power_off_on_close;
 };
 
-// init default values
+struct server {
+    // The internal allocated strings are copies owned by the server
+    struct server_params params;
+
+    process_t process;
+    sc_thread thread;
+
+    sc_mutex mutex;
+
+    sc_cond process_terminated_cond;
+    bool process_terminated;
+
+    sc_cond stopped_cond;
+    bool stopped;
+
+    bool connected; // written by connect_thread
+    struct server_info info; // initialized once connected
+
+    sc_socket server_socket; // only used if !tunnel_forward
+    sc_socket video_socket;
+    sc_socket control_socket;
+    uint16_t local_port; // selected from port_range
+    bool tunnel_enabled;
+    bool tunnel_forward; // use "adb forward" instead of "adb reverse"
+
+    const struct server_callbacks *cbs;
+    void *cbs_userdata;
+};
+
+struct server_callbacks {
+    void (*on_connection_failed)(struct server *server, void *userdata);
+    void (*on_connected)(struct server *server, void *userdata);
+    void (*on_disconnected)(struct server *server, void *userdata);
+};
+
+// init the server with the given params
 bool
-server_init(struct server *server);
+server_init(struct server *server, const struct server_params *params,
+            const struct server_callbacks *cbs, void *cbs_userdata);
 
 // push, enable tunnel et start the server
 bool
-server_start(struct server *server, const struct server_params *params);
+server_start(struct server *server);
 
-#define DEVICE_NAME_FIELD_LENGTH 64
 // block until the communication with the server is established
 // device_name must point to a buffer of at least DEVICE_NAME_FIELD_LENGTH bytes
 bool
-server_connect_to(struct server *server, char *device_name,
-                  struct sc_size *size);
+server_connect_to(struct server *server, struct server_info *info);
 
 // disconnect and kill the server process
 void

app/src/util/net.c

@@ -94,13 +94,18 @@ net_perror(const char *s) {
 }
 
 sc_socket
-net_connect(uint32_t addr, uint16_t port) {
+net_socket(void) {
     sc_raw_socket raw_sock = socket(AF_INET, SOCK_STREAM, 0);
     sc_socket sock = wrap(raw_sock);
     if (sock == SC_INVALID_SOCKET) {
         net_perror("socket");
-        return SC_INVALID_SOCKET;
     }
+    return sock;
+}
+
+bool
+net_connect(sc_socket socket, uint32_t addr, uint16_t port) {
+    sc_raw_socket raw_sock = unwrap(socket);
 
     SOCKADDR_IN sin;
     sin.sin_family = AF_INET;
@@ -109,21 +114,15 @@ net_connect(uint32_t addr, uint16_t port) {
 
     if (connect(raw_sock, (SOCKADDR *) &sin, sizeof(sin)) == SOCKET_ERROR) {
         net_perror("connect");
-        net_close(sock);
-        return SC_INVALID_SOCKET;
+        return false;
     }
 
-    return sock;
+    return true;
 }
 
-sc_socket
-net_listen(uint32_t addr, uint16_t port, int backlog) {
-    sc_raw_socket raw_sock = socket(AF_INET, SOCK_STREAM, 0);
-    sc_socket sock = wrap(raw_sock);
-    if (sock == SC_INVALID_SOCKET) {
-        net_perror("socket");
-        return SC_INVALID_SOCKET;
-    }
+bool
+net_listen(sc_socket socket, uint32_t addr, uint16_t port, int backlog) {
+    sc_raw_socket raw_sock = unwrap(socket);
 
     int reuse = 1;
     if (setsockopt(raw_sock, SOL_SOCKET, SO_REUSEADDR, (const void *) &reuse,
@@ -138,17 +137,15 @@ net_listen(uint32_t addr, uint16_t port, int backlog) {
 
     if (bind(raw_sock, (SOCKADDR *) &sin, sizeof(sin)) == SOCKET_ERROR) {
         net_perror("bind");
-        net_close(sock);
-        return SC_INVALID_SOCKET;
+        return false;
     }
 
     if (listen(raw_sock, backlog) == SOCKET_ERROR) {
         net_perror("listen");
-        net_close(sock);
-        return SC_INVALID_SOCKET;
+        return false;
     }
 
-    return sock;
+    return true;
 }
 
 sc_socket

app/src/util/net.h

@@ -31,10 +31,13 @@ void
 net_cleanup(void);
 
 sc_socket
-net_connect(uint32_t addr, uint16_t port);
+net_socket(void);
 
-sc_socket
-net_listen(uint32_t addr, uint16_t port, int backlog);
+bool
+net_connect(sc_socket socket, uint32_t addr, uint16_t port);
+
+bool
+net_listen(sc_socket socket, uint32_t addr, uint16_t port, int backlog);
 
 sc_socket
 net_accept(sc_socket server_socket);