webrtc-ruby 0.1.0

data/ext/webrtc_ruby/webrtc_ruby.c

@@ -0,0 +1,757 @@
+/*
+ * WebRTC Ruby - libdatachannel wrapper
+ * Real WebRTC implementation using libdatachannel
+ */
+
+#include "webrtc_ruby.h"
+#include <rtc/rtc.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+/* Internal structures to bridge our API with libdatachannel */
+
+struct webrtc_peer_connection {
+    int pc_id;  /* libdatachannel peer connection id */
+    webrtc_ice_candidate_callback ice_candidate_cb;
+    void* ice_candidate_user_data;
+    webrtc_state_change_callback connection_state_cb;
+    void* connection_state_user_data;
+    webrtc_data_channel_callback data_channel_cb;
+    void* data_channel_user_data;
+    char* local_sdp;
+    char* local_type;
+    char* remote_sdp;
+    char* remote_type;
+};
+
+struct webrtc_data_channel {
+    int dc_id;  /* libdatachannel data channel id */
+    struct webrtc_peer_connection* pc;
+    char* label;
+    char* protocol;
+    bool ordered;
+    int max_retransmits;
+    int max_packet_life_time;
+    bool negotiated;
+    int stream_id;
+    webrtc_void_callback open_cb;
+    void* open_user_data;
+    webrtc_message_callback message_cb;
+    void* message_user_data;
+    webrtc_void_callback close_cb;
+    void* close_user_data;
+};
+
+struct webrtc_session_description {
+    char* type;
+    char* sdp;
+};
+
+struct webrtc_ice_candidate {
+    char* candidate;
+    char* sdp_mid;
+    int sdp_mline_index;
+};
+
+/* Global state */
+static bool g_initialized = false;
+
+/* Callback forwarders */
+
+static void on_local_description(int pc, const char* sdp, const char* type, void* ptr) {
+    struct webrtc_peer_connection* conn = (struct webrtc_peer_connection*)ptr;
+    if (conn) {
+        free(conn->local_sdp);
+        free(conn->local_type);
+        conn->local_sdp = sdp ? strdup(sdp) : NULL;
+        conn->local_type = type ? strdup(type) : NULL;
+    }
+}
+
+static void on_local_candidate(int pc, const char* cand, const char* mid, void* ptr) {
+    struct webrtc_peer_connection* conn = (struct webrtc_peer_connection*)ptr;
+    if (conn && conn->ice_candidate_cb && cand) {
+        conn->ice_candidate_cb(cand, mid, 0, conn->ice_candidate_user_data);
+    }
+}
+
+static void on_state_change(int pc, rtcState state, void* ptr) {
+    struct webrtc_peer_connection* conn = (struct webrtc_peer_connection*)ptr;
+    if (conn && conn->connection_state_cb) {
+        conn->connection_state_cb((int)state, conn->connection_state_user_data);
+    }
+}
+
+static void on_data_channel(int pc, int dc, void* ptr) {
+    struct webrtc_peer_connection* conn = (struct webrtc_peer_connection*)ptr;
+    if (conn && conn->data_channel_cb) {
+        /* Create wrapper for incoming data channel */
+        struct webrtc_data_channel* channel = calloc(1, sizeof(struct webrtc_data_channel));
+        if (channel) {
+            channel->dc_id = dc;
+            channel->pc = conn;
+
+            /* Get label */
+            char label_buf[256];
+            if (rtcGetDataChannelLabel(dc, label_buf, sizeof(label_buf)) > 0) {
+                channel->label = strdup(label_buf);
+            }
+
+            /* Get protocol */
+            char proto_buf[256];
+            if (rtcGetDataChannelProtocol(dc, proto_buf, sizeof(proto_buf)) > 0) {
+                channel->protocol = strdup(proto_buf);
+            }
+
+            /* Get reliability */
+            rtcReliability reliability;
+            if (rtcGetDataChannelReliability(dc, &reliability) == 0) {
+                channel->ordered = !reliability.unordered;
+                channel->max_retransmits = reliability.maxRetransmits;
+                channel->max_packet_life_time = reliability.maxPacketLifeTime;
+            }
+
+            channel->stream_id = rtcGetDataChannelStream(dc);
+
+            conn->data_channel_cb(channel, conn->data_channel_user_data);
+        }
+    }
+}
+
+static void on_dc_open(int id, void* ptr) {
+    struct webrtc_data_channel* dc = (struct webrtc_data_channel*)ptr;
+    if (dc && dc->open_cb) {
+        dc->open_cb(dc->open_user_data);
+    }
+}
+
+static void on_dc_message(int id, const char* message, int size, void* ptr) {
+    struct webrtc_data_channel* dc = (struct webrtc_data_channel*)ptr;
+    if (dc && dc->message_cb) {
+        bool is_binary = (size >= 0);
+        int actual_size = (size < 0) ? (int)strlen(message) : size;
+        dc->message_cb((const uint8_t*)message, (size_t)actual_size, is_binary, dc->message_user_data);
+    }
+}
+
+static void on_dc_closed(int id, void* ptr) {
+    struct webrtc_data_channel* dc = (struct webrtc_data_channel*)ptr;
+    if (dc && dc->close_cb) {
+        dc->close_cb(dc->close_user_data);
+    }
+}
+
+/* Public API implementation */
+
+int webrtc_init(void) {
+    if (g_initialized) {
+        return 0;
+    }
+
+    rtcInitLogger(RTC_LOG_WARNING, NULL);
+    rtcPreload();
+    g_initialized = true;
+    return 0;
+}
+
+void webrtc_cleanup(void) {
+    if (g_initialized) {
+        rtcCleanup();
+        g_initialized = false;
+    }
+}
+
+webrtc_peer_connection_t webrtc_peer_connection_create(
+    const webrtc_configuration_t* config,
+    webrtc_error_t* error) {
+
+    struct webrtc_peer_connection* pc = calloc(1, sizeof(struct webrtc_peer_connection));
+    if (!pc) {
+        if (error) {
+            error->code = 1;
+            error->message = "Failed to allocate memory";
+        }
+        return NULL;
+    }
+
+    /* Prepare libdatachannel configuration */
+    rtcConfiguration rtc_config;
+    memset(&rtc_config, 0, sizeof(rtc_config));
+
+    if (config && config->ice_servers && config->ice_servers_count > 0) {
+        rtc_config.iceServers = config->ice_servers;
+        rtc_config.iceServersCount = (int)config->ice_servers_count;
+    }
+
+    /* Create peer connection */
+    int pc_id = rtcCreatePeerConnection(&rtc_config);
+    if (pc_id < 0) {
+        free(pc);
+        if (error) {
+            error->code = 1;
+            error->message = "Failed to create peer connection";
+        }
+        return NULL;
+    }
+
+    pc->pc_id = pc_id;
+
+    /* Set user pointer for callbacks */
+    rtcSetUserPointer(pc_id, pc);
+
+    /* Set up callbacks */
+    rtcSetLocalDescriptionCallback(pc_id, on_local_description);
+    rtcSetLocalCandidateCallback(pc_id, on_local_candidate);
+    rtcSetStateChangeCallback(pc_id, on_state_change);
+    rtcSetDataChannelCallback(pc_id, on_data_channel);
+
+    if (error) {
+        error->code = 0;
+        error->message = NULL;
+    }
+
+    return pc;
+}
+
+void webrtc_peer_connection_destroy(webrtc_peer_connection_t pc) {
+    if (pc) {
+        rtcDeletePeerConnection(pc->pc_id);
+        free(pc->local_sdp);
+        free(pc->local_type);
+        free(pc->remote_sdp);
+        free(pc->remote_type);
+        free(pc);
+    }
+}
+
+int webrtc_peer_connection_create_offer(
+    webrtc_peer_connection_t pc,
+    webrtc_session_description_t* out_sdp,
+    webrtc_error_t* error) {
+
+    if (!pc || !out_sdp) {
+        if (error) {
+            error->code = 1;
+            error->message = "Invalid argument";
+        }
+        return -1;
+    }
+
+    /* Set local description with type "offer" */
+    int ret = rtcSetLocalDescription(pc->pc_id, "offer");
+    if (ret < 0) {
+        if (error) {
+            error->code = 1;
+            error->message = "Failed to create offer";
+        }
+        return -1;
+    }
+
+    /* Get the generated SDP */
+    char sdp_buf[16384];
+    int sdp_len = rtcGetLocalDescription(pc->pc_id, sdp_buf, sizeof(sdp_buf));
+    if (sdp_len < 0) {
+        if (error) {
+            error->code = 1;
+            error->message = "Failed to get local description";
+        }
+        return -1;
+    }
+
+    *out_sdp = webrtc_session_description_create("offer", sdp_buf, error);
+    if (!*out_sdp) {
+        return -1;
+    }
+
+    if (error) {
+        error->code = 0;
+        error->message = NULL;
+    }
+    return 0;
+}
+
+int webrtc_peer_connection_create_answer(
+    webrtc_peer_connection_t pc,
+    webrtc_session_description_t* out_sdp,
+    webrtc_error_t* error) {
+
+    if (!pc || !out_sdp) {
+        if (error) {
+            error->code = 1;
+            error->message = "Invalid argument";
+        }
+        return -1;
+    }
+
+    /* Set local description with type "answer" */
+    int ret = rtcSetLocalDescription(pc->pc_id, "answer");
+    if (ret < 0) {
+        if (error) {
+            error->code = 1;
+            error->message = "Failed to create answer";
+        }
+        return -1;
+    }
+
+    /* Get the generated SDP */
+    char sdp_buf[16384];
+    int sdp_len = rtcGetLocalDescription(pc->pc_id, sdp_buf, sizeof(sdp_buf));
+    if (sdp_len < 0) {
+        if (error) {
+            error->code = 1;
+            error->message = "Failed to get local description";
+        }
+        return -1;
+    }
+
+    *out_sdp = webrtc_session_description_create("answer", sdp_buf, error);
+    if (!*out_sdp) {
+        return -1;
+    }
+
+    if (error) {
+        error->code = 0;
+        error->message = NULL;
+    }
+    return 0;
+}
+
+int webrtc_peer_connection_set_local_description(
+    webrtc_peer_connection_t pc,
+    webrtc_session_description_t sdp,
+    webrtc_error_t* error) {
+
+    if (!pc || !sdp) {
+        if (error) {
+            error->code = 1;
+            error->message = "Invalid argument";
+        }
+        return -1;
+    }
+
+    /* Store local description */
+    free(pc->local_sdp);
+    free(pc->local_type);
+    pc->local_sdp = sdp->sdp ? strdup(sdp->sdp) : NULL;
+    pc->local_type = sdp->type ? strdup(sdp->type) : NULL;
+
+    /* libdatachannel handles this through rtcSetLocalDescription in create_offer/answer */
+
+    if (error) {
+        error->code = 0;
+        error->message = NULL;
+    }
+    return 0;
+}
+
+int webrtc_peer_connection_set_remote_description(
+    webrtc_peer_connection_t pc,
+    webrtc_session_description_t sdp,
+    webrtc_error_t* error) {
+
+    if (!pc || !sdp) {
+        if (error) {
+            error->code = 1;
+            error->message = "Invalid argument";
+        }
+        return -1;
+    }
+
+    const char* sdp_str = sdp->sdp ? sdp->sdp : "";
+    const char* type_str = sdp->type ? sdp->type : "offer";
+
+    int ret = rtcSetRemoteDescription(pc->pc_id, sdp_str, type_str);
+    if (ret < 0) {
+        if (error) {
+            error->code = 1;
+            error->message = "Failed to set remote description";
+        }
+        return -1;
+    }
+
+    /* Store remote description */
+    free(pc->remote_sdp);
+    free(pc->remote_type);
+    pc->remote_sdp = strdup(sdp_str);
+    pc->remote_type = strdup(type_str);
+
+    if (error) {
+        error->code = 0;
+        error->message = NULL;
+    }
+    return 0;
+}
+
+int webrtc_peer_connection_add_ice_candidate(
+    webrtc_peer_connection_t pc,
+    webrtc_ice_candidate_t candidate,
+    webrtc_error_t* error) {
+
+    if (!pc) {
+        if (error) {
+            error->code = 1;
+            error->message = "Invalid argument";
+        }
+        return -1;
+    }
+
+    if (candidate && candidate->candidate) {
+        const char* mid = candidate->sdp_mid ? candidate->sdp_mid : "";
+        int ret = rtcAddRemoteCandidate(pc->pc_id, candidate->candidate, mid);
+        if (ret < 0) {
+            if (error) {
+                error->code = 1;
+                error->message = "Failed to add ICE candidate";
+            }
+            return -1;
+        }
+    }
+
+    if (error) {
+        error->code = 0;
+        error->message = NULL;
+    }
+    return 0;
+}
+
+void webrtc_peer_connection_on_ice_candidate(
+    webrtc_peer_connection_t pc,
+    webrtc_ice_candidate_callback callback,
+    void* user_data) {
+    if (pc) {
+        pc->ice_candidate_cb = callback;
+        pc->ice_candidate_user_data = user_data;
+    }
+}
+
+void webrtc_peer_connection_on_connection_state_change(
+    webrtc_peer_connection_t pc,
+    webrtc_state_change_callback callback,
+    void* user_data) {
+    if (pc) {
+        pc->connection_state_cb = callback;
+        pc->connection_state_user_data = user_data;
+    }
+}
+
+void webrtc_peer_connection_on_data_channel(
+    webrtc_peer_connection_t pc,
+    webrtc_data_channel_callback callback,
+    void* user_data) {
+    if (pc) {
+        pc->data_channel_cb = callback;
+        pc->data_channel_user_data = user_data;
+    }
+}
+
+int webrtc_peer_connection_get_signaling_state(webrtc_peer_connection_t pc) {
+    if (!pc) return -1;
+
+    char buf[64];
+    int ret = rtcGetLocalDescriptionType(pc->pc_id, buf, sizeof(buf));
+
+    /* Map to our signaling state enum:
+     * 0 = stable
+     * 1 = have-local-offer
+     * 2 = have-remote-offer
+     */
+    if (ret < 0) {
+        return 0; /* stable */
+    }
+
+    if (strcmp(buf, "offer") == 0) {
+        return 1; /* have-local-offer */
+    }
+
+    return 0;
+}
+
+int webrtc_peer_connection_get_ice_gathering_state(webrtc_peer_connection_t pc) {
+    /* libdatachannel doesn't expose this directly in C API */
+    /* Return 0 (new) as default */
+    return pc ? 0 : -1;
+}
+
+int webrtc_peer_connection_get_ice_connection_state(webrtc_peer_connection_t pc) {
+    /* libdatachannel doesn't expose this separately */
+    return pc ? 0 : -1;
+}
+
+int webrtc_peer_connection_get_connection_state(webrtc_peer_connection_t pc) {
+    /* libdatachannel doesn't expose state getter in C API */
+    /* Return 0 (new) as default */
+    return pc ? 0 : -1;
+}
+
+webrtc_data_channel_t webrtc_peer_connection_create_data_channel(
+    webrtc_peer_connection_t pc,
+    const char* label,
+    bool ordered,
+    int max_retransmits,
+    int max_packet_life_time,
+    const char* protocol,
+    bool negotiated,
+    int id,
+    webrtc_error_t* error) {
+
+    if (!pc) {
+        if (error) {
+            error->code = 1;
+            error->message = "Invalid peer connection";
+        }
+        return NULL;
+    }
+
+    struct webrtc_data_channel* dc = calloc(1, sizeof(struct webrtc_data_channel));
+    if (!dc) {
+        if (error) {
+            error->code = 1;
+            error->message = "Failed to allocate memory";
+        }
+        return NULL;
+    }
+
+    /* Prepare data channel init */
+    rtcDataChannelInit init;
+    memset(&init, 0, sizeof(init));
+    init.reliability.unordered = !ordered;
+    init.reliability.unreliable = (max_retransmits >= 0 || max_packet_life_time >= 0);
+
+    if (max_retransmits >= 0) {
+        init.reliability.maxRetransmits = (unsigned int)max_retransmits;
+    }
+    if (max_packet_life_time >= 0) {
+        init.reliability.maxPacketLifeTime = (unsigned int)max_packet_life_time;
+    }
+
+    init.protocol = protocol;
+    init.negotiated = negotiated;
+
+    if (id >= 0) {
+        init.manualStream = true;
+        init.stream = (uint16_t)id;
+    }
+
+    /* Create data channel */
+    int dc_id = rtcCreateDataChannelEx(pc->pc_id, label ? label : "", &init);
+    if (dc_id < 0) {
+        free(dc);
+        if (error) {
+            error->code = 1;
+            error->message = "Failed to create data channel";
+        }
+        return NULL;
+    }
+
+    dc->dc_id = dc_id;
+    dc->pc = pc;
+    dc->label = label ? strdup(label) : NULL;
+    dc->protocol = protocol ? strdup(protocol) : NULL;
+    dc->ordered = ordered;
+    dc->max_retransmits = max_retransmits;
+    dc->max_packet_life_time = max_packet_life_time;
+    dc->negotiated = negotiated;
+    dc->stream_id = rtcGetDataChannelStream(dc_id);
+
+    /* Set user pointer and callbacks */
+    rtcSetUserPointer(dc_id, dc);
+    rtcSetOpenCallback(dc_id, on_dc_open);
+    rtcSetMessageCallback(dc_id, on_dc_message);
+    rtcSetClosedCallback(dc_id, on_dc_closed);
+
+    if (error) {
+        error->code = 0;
+        error->message = NULL;
+    }
+
+    return dc;
+}
+
+void webrtc_data_channel_destroy(webrtc_data_channel_t dc) {
+    if (dc) {
+        rtcDeleteDataChannel(dc->dc_id);
+        free(dc->label);
+        free(dc->protocol);
+        free(dc);
+    }
+}
+
+int webrtc_data_channel_send(webrtc_data_channel_t dc,
+                             const uint8_t* data,
+                             size_t length,
+                             bool is_binary,
+                             webrtc_error_t* error) {
+    if (!dc) {
+        if (error) {
+            error->code = 1;
+            error->message = "Invalid data channel";
+        }
+        return -1;
+    }
+
+    int ret;
+    if (is_binary) {
+        ret = rtcSendMessage(dc->dc_id, (const char*)data, (int)length);
+    } else {
+        /* For text, size should be -1 to indicate null-terminated string */
+        ret = rtcSendMessage(dc->dc_id, (const char*)data, -1);
+    }
+
+    if (ret < 0) {
+        if (error) {
+            error->code = 1;
+            error->message = "Failed to send message";
+        }
+        return -1;
+    }
+
+    if (error) {
+        error->code = 0;
+        error->message = NULL;
+    }
+    return 0;
+}
+
+void webrtc_data_channel_close(webrtc_data_channel_t dc) {
+    if (dc) {
+        rtcClose(dc->dc_id);
+    }
+}
+
+int webrtc_data_channel_get_ready_state(webrtc_data_channel_t dc) {
+    if (!dc) return -1;
+
+    if (rtcIsClosed(dc->dc_id)) {
+        return 3; /* closed */
+    }
+    if (rtcIsOpen(dc->dc_id)) {
+        return 1; /* open */
+    }
+    return 0; /* connecting */
+}
+
+const char* webrtc_data_channel_get_label(webrtc_data_channel_t dc) {
+    return dc ? dc->label : NULL;
+}
+
+size_t webrtc_data_channel_get_buffered_amount(webrtc_data_channel_t dc) {
+    if (!dc) return 0;
+    int amount = rtcGetBufferedAmount(dc->dc_id);
+    return amount >= 0 ? (size_t)amount : 0;
+}
+
+void webrtc_data_channel_on_open(webrtc_data_channel_t dc,
+                                  webrtc_void_callback callback,
+                                  void* user_data) {
+    if (dc) {
+        dc->open_cb = callback;
+        dc->open_user_data = user_data;
+    }
+}
+
+void webrtc_data_channel_on_message(webrtc_data_channel_t dc,
+                                     webrtc_message_callback callback,
+                                     void* user_data) {
+    if (dc) {
+        dc->message_cb = callback;
+        dc->message_user_data = user_data;
+    }
+}
+
+void webrtc_data_channel_on_close(webrtc_data_channel_t dc,
+                                   webrtc_void_callback callback,
+                                   void* user_data) {
+    if (dc) {
+        dc->close_cb = callback;
+        dc->close_user_data = user_data;
+    }
+}
+
+webrtc_session_description_t webrtc_session_description_create(
+    const char* type,
+    const char* sdp,
+    webrtc_error_t* error) {
+
+    struct webrtc_session_description* sd = calloc(1, sizeof(struct webrtc_session_description));
+    if (!sd) {
+        if (error) {
+            error->code = 1;
+            error->message = "Failed to allocate memory";
+        }
+        return NULL;
+    }
+
+    sd->type = type ? strdup(type) : NULL;
+    sd->sdp = sdp ? strdup(sdp) : NULL;
+
+    if (error) {
+        error->code = 0;
+        error->message = NULL;
+    }
+
+    return sd;
+}
+
+void webrtc_session_description_destroy(webrtc_session_description_t sd) {
+    if (sd) {
+        free(sd->type);
+        free(sd->sdp);
+        free(sd);
+    }
+}
+
+const char* webrtc_session_description_get_type(webrtc_session_description_t sd) {
+    return sd ? sd->type : NULL;
+}
+
+const char* webrtc_session_description_get_sdp(webrtc_session_description_t sd) {
+    return sd ? sd->sdp : NULL;
+}
+
+webrtc_ice_candidate_t webrtc_ice_candidate_create(
+    const char* candidate,
+    const char* sdp_mid,
+    int sdp_mline_index,
+    webrtc_error_t* error) {
+
+    struct webrtc_ice_candidate* ic = calloc(1, sizeof(struct webrtc_ice_candidate));
+    if (!ic) {
+        if (error) {
+            error->code = 1;
+            error->message = "Failed to allocate memory";
+        }
+        return NULL;
+    }
+
+    ic->candidate = candidate ? strdup(candidate) : NULL;
+    ic->sdp_mid = sdp_mid ? strdup(sdp_mid) : NULL;
+    ic->sdp_mline_index = sdp_mline_index;
+
+    if (error) {
+        error->code = 0;
+        error->message = NULL;
+    }
+
+    return ic;
+}
+
+void webrtc_ice_candidate_destroy(webrtc_ice_candidate_t ic) {
+    if (ic) {
+        free(ic->candidate);
+        free(ic->sdp_mid);
+        free(ic);
+    }
+}
+
+const char* webrtc_ice_candidate_get_candidate(webrtc_ice_candidate_t ic) {
+    return ic ? ic->candidate : NULL;
+}
+
+const char* webrtc_ice_candidate_get_sdp_mid(webrtc_ice_candidate_t ic) {
+    return ic ? ic->sdp_mid : NULL;
+}
+
+int webrtc_ice_candidate_get_sdp_mline_index(webrtc_ice_candidate_t ic) {
+    return ic ? ic->sdp_mline_index : -1;
+}