static void skipped_cb (GObject *istream, GAsyncResult *result, gpointer user_data) { TestSession *ses = user_data; FsCandidate *cand; GList *cands = NULL; GError *error = NULL; gboolean res; cand = fs_candidate_new ("", FS_COMPONENT_RTP, FS_CANDIDATE_TYPE_HOST, FS_NETWORK_PROTOCOL_UDP, ses->send_socket, 0); cand->username = g_strdup (ses->recv_socket); cands = g_list_prepend (NULL, cand); res = fs_stream_force_remote_candidates (ses->stream, cands, &error); print_error (error); g_assert (res); fs_candidate_list_destroy (cands); }
static void _upnp_mapped_external_port (GUPnPSimpleIgdThread *igd, gchar *proto, gchar *external_ip, gchar *replaces_external_ip, guint external_port, gchar *local_ip, guint local_port, gchar *description, gpointer user_data) { FsRawUdpComponent *self = FS_RAWUDP_COMPONENT (user_data); FS_RAWUDP_COMPONENT_LOCK (self); /* Skip it if its not our port */ if (fs_rawudp_transmitter_udpport_get_port (self->priv->udpport) != external_port) { FS_RAWUDP_COMPONENT_UNLOCK (self); return; } fs_rawudp_component_stop_upnp_discovery_locked (self); if (self->priv->local_upnp_candidate || self->priv->local_active_candidate) { FS_RAWUDP_COMPONENT_UNLOCK (self); return; } self->priv->local_upnp_candidate = fs_candidate_new ("L1", self->priv->component, FS_CANDIDATE_TYPE_HOST, FS_NETWORK_PROTOCOL_UDP, external_ip, external_port); GST_DEBUG ("Got UPnP Candidate c:%d ext-ip:%s ext-port:%u" " int-ip:%s int-port:%u", self->priv->component, external_ip, external_port, local_ip, local_port); FS_RAWUDP_COMPONENT_UNLOCK (self); fs_rawudp_component_maybe_emit_local_candidates (self); }
static void multicast_init (struct SimpleTestStream *st, guint confid, guint streamid) { GList *candidates = NULL; FsCandidate *cand; GError *error = NULL; cand = fs_candidate_new ("1", FS_COMPONENT_RTP, FS_CANDIDATE_TYPE_MULTICAST, FS_NETWORK_PROTOCOL_UDP, "224.0.0.11", 2324); cand->ttl = 1; candidates = g_list_prepend (candidates, cand); cand = fs_candidate_copy (cand); cand->component_id = FS_COMPONENT_RTCP; cand->port = 2325; candidates = g_list_prepend (candidates, cand); ts_fail_unless (fs_stream_force_remote_candidates (st->stream, candidates, &error), "Error %s", error ? error->message : "No GError"); fs_candidate_list_destroy (candidates); }
static TestSession* add_audio_session (GstElement *pipeline, FsConference *conf, guint id, FsParticipant *part, gchar *send_socket, gchar *recv_socket) { TestSession *ses = g_slice_new0 (TestSession); GError *error = NULL; GstPad *pad = NULL, *pad2 = NULL; GstElement *src = NULL; GList *cands = NULL; GParameter param = {0}; gboolean res; FsCandidate *cand; GList *codecs = NULL; ses->send_socket = send_socket; ses->recv_socket = recv_socket; ses->session = fs_conference_new_session (conf, FS_MEDIA_TYPE_AUDIO, &error); print_error (error); g_assert (ses->session); g_object_get (ses->session, "sink-pad", &pad, NULL); if (g_getenv ("AUDIOSRC")) src = gst_parse_bin_from_description (g_getenv ("AUDIOSRC"), TRUE, &error); else src = gst_parse_bin_from_description (DEFAULT_AUDIOSRC, TRUE, &error); print_error (error); g_assert (src); g_assert (gst_bin_add (GST_BIN (pipeline), src)); pad2 = gst_element_get_static_pad (src, "src"); g_assert (pad2); g_assert (GST_PAD_LINK_SUCCESSFUL (gst_pad_link (pad2, pad))); gst_object_unref (pad2); gst_object_unref (pad); ses->stream = fs_session_new_stream (ses->session, part, FS_DIRECTION_BOTH, &error); print_error (error); g_assert (ses->stream); cand = fs_candidate_new ("", FS_COMPONENT_RTP, FS_CANDIDATE_TYPE_HOST, FS_NETWORK_PROTOCOL_UDP, send_socket, 0); cands = g_list_prepend (NULL, cand); param.name = "preferred-local-candidates"; g_value_init (¶m.value, FS_TYPE_CANDIDATE_LIST); g_value_take_boxed (¶m.value, cands); res = fs_stream_set_transmitter (ses->stream, "shm", ¶m, 1, &error); print_error (error); g_value_unset (¶m.value); g_signal_connect (ses->stream, "src-pad-added", G_CALLBACK (src_pad_added_cb), pipeline); codecs = g_list_prepend (NULL, fs_codec_new (FS_CODEC_ID_ANY, "PCMA", FS_MEDIA_TYPE_AUDIO, 0)); codecs = g_list_prepend (codecs, fs_codec_new (FS_CODEC_ID_ANY, "PCMU", FS_MEDIA_TYPE_AUDIO, 0)); res = fs_session_set_codec_preferences (ses->session, codecs, &error); print_error (error); fs_codec_list_destroy (codecs); g_object_get (ses->session, "codecs-without-config", &codecs, NULL); res = fs_stream_set_remote_codecs (ses->stream, codecs, &error); print_error (error); g_assert (res); return ses; }
static gboolean fs_msn_open_listening_port_unlock (FsMsnConnection *self, guint16 port, GError **error) { gint fd = -1; struct sockaddr_in myaddr; guint myaddr_len = sizeof (struct sockaddr_in); FsCandidate * candidate = NULL; GList *addresses = nice_interfaces_get_local_ips (FALSE); GList *item = NULL; gchar *session_id; addresses = filter_ips_ipv4 (addresses); GST_DEBUG ("Attempting to listen on port %d.....",port); if ( (fd = socket(PF_INET, SOCK_STREAM, 0)) < 0 ) { gchar error_str[256]; strerror_r (errno, error_str, 256); g_set_error (error, FS_ERROR, FS_ERROR_NETWORK, "Could not create socket: %s", error_str); goto error; } // set non-blocking mode fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK); for (;;) { GST_DEBUG ("Attempting to listen on port %d.....",port); memset(&myaddr, 0, sizeof(myaddr)); myaddr.sin_family = AF_INET; myaddr.sin_port = htons (port); // bind if (bind(fd, (struct sockaddr *) &myaddr, sizeof(myaddr)) != 0) { if (port != 0 && errno == EADDRINUSE) { port++; } else { gchar error_str[256]; strerror_r (errno, error_str, 256); g_set_error (error, FS_ERROR, FS_ERROR_NETWORK, "Could not bind socket: %s", error_str); goto error; } } else { /* Listen */ if (listen(fd, 3) != 0) { if (port != 0 && errno == EADDRINUSE) { port++; } else { gchar error_str[256]; strerror_r (errno, error_str, 256); g_set_error (error, FS_ERROR, FS_ERROR_NETWORK, "Could not listen on socket: %s", error_str); goto error; } } else { goto done; } } } done: if (getsockname (fd, (struct sockaddr *) &myaddr, &myaddr_len) < 0) { gchar error_str[256]; strerror_r (errno, error_str, 256); g_set_error (error, FS_ERROR, FS_ERROR_NETWORK, "Could not get the socket name: %s", error_str); goto error; } port = ntohs (myaddr.sin_port); add_pollfd_locked (self, fd, accept_connection_cb, TRUE, TRUE, FALSE); GST_DEBUG ("Listening on port %d", port); self->local_recipient_id = g_strdup_printf ("%d", g_random_int_range (100, 199)); session_id = g_strdup_printf ("%u", self->session_id); FS_MSN_CONNECTION_UNLOCK (self); for (item = addresses; item; item = g_list_next (item)) { candidate = fs_candidate_new (self->local_recipient_id, 1, FS_CANDIDATE_TYPE_HOST, FS_NETWORK_PROTOCOL_TCP, item->data, port); candidate->username = g_strdup (session_id); g_signal_emit (self, signals[SIGNAL_NEW_LOCAL_CANDIDATE], 0, candidate); fs_candidate_destroy (candidate); } g_free (session_id); g_list_foreach (addresses, (GFunc) g_free, NULL); g_list_free (addresses); return TRUE; error: if (fd >= 0) close (fd); g_list_foreach (addresses, (GFunc) g_free, NULL); g_list_free (addresses); FS_MSN_CONNECTION_UNLOCK (self); return FALSE; }
static void one_way (GCallback havedata_handler, gpointer data) { FsParticipant *participant = NULL; GError *error = NULL; gint port = 0; GstElement *recv_pipeline; GList *candidates = NULL; GstBus *bus = NULL; dtmf_id = 105; digit = 0; sending = FALSE; received = FALSE; ready_to_send = FALSE; loop = g_main_loop_new (NULL, FALSE); dat = setup_simple_conference (1, "fsrtpconference", "tester@123445"); bus = gst_element_get_bus (dat->pipeline); gst_bus_add_watch (bus, _bus_callback, dat); gst_object_unref (bus); g_idle_add (_start_pipeline, dat); participant = fs_conference_new_participant ( FS_CONFERENCE (dat->conference), "*****@*****.**", &error); if (error) ts_fail ("Error while creating new participant (%d): %s", error->code, error->message); ts_fail_if (dat->session == NULL, "Could not make participant, but no GError!"); stream = fs_session_new_stream (dat->session, participant, FS_DIRECTION_SEND, "rawudp", 0, NULL, &error); if (error) ts_fail ("Error while creating new stream (%d): %s", error->code, error->message); ts_fail_if (stream == NULL, "Could not make stream, but no GError!"); recv_pipeline = build_recv_pipeline (havedata_handler, NULL, &port); GST_DEBUG ("port is %d", port); candidates = g_list_prepend (NULL, fs_candidate_new ("1", FS_COMPONENT_RTP, FS_CANDIDATE_TYPE_HOST, FS_NETWORK_PROTOCOL_UDP, "127.0.0.1", port)); ts_fail_unless (fs_stream_set_remote_candidates (stream, candidates, &error), "Could not set remote candidate"); fs_candidate_list_destroy (candidates); set_codecs (dat, stream); setup_fakesrc (dat); g_main_loop_run (loop); gst_element_set_state (dat->pipeline, GST_STATE_NULL); gst_element_set_state (recv_pipeline, GST_STATE_NULL); cleanup_simple_conference (dat); gst_object_unref (recv_pipeline); g_main_loop_unref (loop); }
static void run_shm_transmitter_test (gint flags) { GError *error = NULL; FsTransmitter *trans; FsStreamTransmitter *st; GstBus *bus = NULL; GParameter params[1]; GList *local_cands = NULL; GstStateChangeReturn ret; FsCandidate *cand; GList *remote_cands = NULL; int param_count = 0; gint bus_source; done = FALSE; connected_count = 0; g_cond_init (&cond); g_mutex_init (&test_mutex); buffer_count[0] = 0; buffer_count[1] = 0; received_known[0] = 0; received_known[1] = 0; got_candidates[0] = FALSE; got_candidates[1] = FALSE; got_prepared[0] = FALSE; got_prepared[1] = FALSE; if (unlink ("/tmp/src1") < 0 && errno != ENOENT) fail ("Could not unlink /tmp/src1: %s", strerror (errno)); if (unlink ("/tmp/src2") < 0 && errno != ENOENT) fail ("Could not unlink /tmp/src2: %s", strerror (errno)); local_cands = g_list_append (local_cands, fs_candidate_new (NULL, 1, FS_CANDIDATE_TYPE_HOST, FS_NETWORK_PROTOCOL_UDP, "/tmp/src1", 0)); local_cands = g_list_append (local_cands, fs_candidate_new (NULL, 2, FS_CANDIDATE_TYPE_HOST, FS_NETWORK_PROTOCOL_UDP, "/tmp/src2", 0)); if (flags & FLAG_LOCAL_CANDIDATES) { memset (params, 0, sizeof (GParameter)); params[0].name = "preferred-local-candidates"; g_value_init (¶ms[0].value, FS_TYPE_CANDIDATE_LIST); g_value_take_boxed (¶ms[0].value, local_cands); param_count = 1; } associate_on_source = !(flags & FLAG_NO_SOURCE); if ((flags & FLAG_NOT_SENDING) && (flags & FLAG_RECVONLY_FILTER)) { buffer_count[0] = 20; received_known[0] = 20; } trans = fs_transmitter_new ("shm", 2, 0, &error); if (error) ts_fail ("Error creating transmitter: (%s:%d) %s", g_quark_to_string (error->domain), error->code, error->message); ts_fail_if (trans == NULL, "No transmitter create, yet error is still NULL"); g_clear_error (&error); if (flags & FLAG_RECVONLY_FILTER) ts_fail_unless (g_signal_connect (trans, "get-recvonly-filter", G_CALLBACK (get_recvonly_filter), NULL)); pipeline = setup_pipeline (trans, G_CALLBACK (_handoff_handler)); bus = gst_element_get_bus (pipeline); bus_source = gst_bus_add_watch (bus, bus_error_callback, NULL); gst_bus_enable_sync_message_emission (bus); g_signal_connect (bus, "sync-message::error", G_CALLBACK (sync_error_handler), NULL); gst_object_unref (bus); st = fs_transmitter_new_stream_transmitter (trans, NULL, param_count, params, &error); if (param_count) g_value_unset (¶ms[0].value); if (error) ts_fail ("Error creating stream transmitter: (%s:%d) %s", g_quark_to_string (error->domain), error->code, error->message); ts_fail_if (st == NULL, "No stream transmitter created, yet error is NULL"); g_clear_error (&error); g_object_set (st, "sending", !(flags & FLAG_NOT_SENDING), NULL); ts_fail_unless (g_signal_connect (st, "new-local-candidate", G_CALLBACK (_new_local_candidate), trans), "Could not connect new-local-candidate signal"); ts_fail_unless (g_signal_connect (st, "local-candidates-prepared", G_CALLBACK (_candidate_prepared), NULL), "Could not connect local-candidates-prepared signal"); ts_fail_unless (g_signal_connect (st, "error", G_CALLBACK (stream_transmitter_error), NULL), "Could not connect error signal"); ts_fail_unless (g_signal_connect (st, "known-source-packet-received", G_CALLBACK (_known_source_packet_received), NULL), "Could not connect known-source-packet-received signal"); ts_fail_unless (g_signal_connect (st, "state-changed", G_CALLBACK (_state_changed), NULL), "Could not connect state-changed signal"); if (!fs_stream_transmitter_gather_local_candidates (st, &error)) { if (error) ts_fail ("Could not start gathering local candidates (%s:%d) %s", g_quark_to_string (error->domain), error->code, error->message); else ts_fail ("Could not start gathering candidates" " (without a specified error)"); } else { ts_fail_unless (error == NULL); } g_clear_error (&error); ret = gst_element_set_state (pipeline, GST_STATE_PLAYING); ts_fail_if (ret == GST_STATE_CHANGE_FAILURE, "Could not set the pipeline to playing"); if (!(flags & FLAG_LOCAL_CANDIDATES)) { ret = fs_stream_transmitter_force_remote_candidates (st, local_cands, &error); fs_candidate_list_destroy (local_cands); if (error) ts_fail ("Error while adding candidate: (%s:%d) %s", g_quark_to_string (error->domain), error->code, error->message); ts_fail_unless (ret == TRUE, "No detailed error from add_remote_candidate"); } else { ts_fail_unless (error == NULL); } g_clear_error (&error); cand = fs_candidate_new (NULL, 1, FS_CANDIDATE_TYPE_HOST, FS_NETWORK_PROTOCOL_UDP, NULL, 0); cand->username = g_strdup ("/tmp/src1"); remote_cands = g_list_prepend (remote_cands, cand); cand = fs_candidate_new (NULL, 2, FS_CANDIDATE_TYPE_HOST, FS_NETWORK_PROTOCOL_UDP, NULL, 0); cand->username = g_strdup ("/tmp/src2"); remote_cands = g_list_prepend (remote_cands, cand); ret = fs_stream_transmitter_force_remote_candidates (st, remote_cands, &error); fs_candidate_list_destroy (remote_cands); if (error) ts_fail ("Error while adding candidate: (%s:%d) %s", g_quark_to_string (error->domain), error->code, error->message); ts_fail_unless (ret == TRUE, "No detailed error from add_remote_candidate"); g_clear_error (&error); g_mutex_lock (&test_mutex); while (connected_count < 2) g_cond_wait (&cond, &test_mutex); g_mutex_unlock (&test_mutex); setup_fakesrc (trans, pipeline, 1); setup_fakesrc (trans, pipeline, 2); g_mutex_lock (&test_mutex); while (!done) g_cond_wait (&cond, &test_mutex); g_mutex_unlock (&test_mutex); fail_unless (got_prepared[0] == TRUE); fail_unless (got_prepared[1] == TRUE); fail_unless (got_candidates[0] == TRUE); fail_unless (got_candidates[1] == TRUE); gst_element_set_state (pipeline, GST_STATE_NULL); if (st) { fs_stream_transmitter_stop (st); g_object_unref (st); } g_object_unref (trans); g_source_remove (bus_source); gst_object_unref (pipeline); g_cond_clear (&cond); g_mutex_clear (&test_mutex); }
static void run_multicast_transmitter_test (gint n_parameters, GParameter *params) { GError *error = NULL; FsTransmitter *trans; FsStreamTransmitter *st; FsCandidate *tmpcand = NULL; GList *candidates = NULL; GstBus *bus = NULL; loop = g_main_loop_new (NULL, FALSE); trans = fs_transmitter_new ("multicast", 2, &error); if (error) { ts_fail ("Error creating transmitter: (%s:%d) %s", g_quark_to_string (error->domain), error->code, error->message); } ts_fail_if (trans == NULL, "No transmitter create, yet error is still NULL"); pipeline = setup_pipeline (trans, G_CALLBACK (_handoff_handler)); st = fs_transmitter_new_stream_transmitter (trans, NULL, n_parameters, params, &error); if (error) { ts_fail ("Error creating stream transmitter: (%s:%d) %s", g_quark_to_string (error->domain), error->code, error->message); } ts_fail_if (st == NULL, "No stream transmitter created, yet error is NULL"); bus = gst_element_get_bus (pipeline); gst_bus_add_watch (bus, bus_error_callback, NULL); gst_object_unref (bus); ts_fail_unless (g_signal_connect (st, "new-active-candidate-pair", G_CALLBACK (_new_active_candidate_pair), trans), "Coult not connect new-active-candidate-pair signal"); ts_fail_unless (g_signal_connect (st, "error", G_CALLBACK (stream_transmitter_error), NULL), "Could not connect error signal"); g_idle_add (_start_pipeline, pipeline); tmpcand = fs_candidate_new ("L1", FS_COMPONENT_RTP, FS_CANDIDATE_TYPE_MULTICAST, FS_NETWORK_PROTOCOL_UDP, "224.0.0.110", 2322); tmpcand->ttl = 1; candidates = g_list_prepend (candidates, tmpcand); tmpcand = fs_candidate_new ("L2", FS_COMPONENT_RTCP, FS_CANDIDATE_TYPE_MULTICAST, FS_NETWORK_PROTOCOL_UDP, "224.0.0.110", 2323); tmpcand->ttl = 1; candidates = g_list_prepend (candidates, tmpcand); if (!fs_stream_transmitter_set_remote_candidates (st, candidates, &error)) ts_fail ("Error setting the remote candidates: %p %s", error, error ? error->message : "NO ERROR SET"); ts_fail_unless (error == NULL, "Error is not null after successful candidate" " addition"); fs_candidate_list_destroy (candidates); g_main_run (loop); g_object_unref (st); g_object_unref (trans); gst_element_set_state (pipeline, GST_STATE_NULL); gst_object_unref (pipeline); g_main_loop_unref (loop); }