void lllp_next_song_cb(GObject *listener, GAsyncResult *res, gpointer pstore_library) { GtkListStore *store_library = GTK_LIST_STORE(pstore_library); gboolean valid = FALSE; GSocketConnection *connection; GSocketClient *player_client; GSocketAddress *address; GSocket *socket; GInputStream *stream; GOutputStream *output_stream; GInetAddress *inet_address; GInetAddress *player_with_the_song; GtkTreeIter iter; gchar *player_with_the_song_char; struct force_vector_s force_vector; gchar *remote_file; gint random_number; gsize count = 0; int i; struct force_vector_s rand_force_vector; connection = g_socket_listener_accept_finish(G_SOCKET_LISTENER(listener), res, NULL, NULL); address = g_socket_connection_get_remote_address(connection, NULL); inet_address = g_inet_socket_address_get_address(G_INET_SOCKET_ADDRESS(address)); socket = g_socket_connection_get_socket(connection); stream = g_io_stream_get_input_stream(G_IO_STREAM(connection)); g_input_stream_read_all(stream, &force_vector, sizeof(force_vector), NULL, NULL, NULL); valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store_library), &iter); while(valid == TRUE) { valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(store_library), &iter); count++; } gint rand; float distance = 100, old_distance = 100; float treshold = 0.95; float treshold_distance = 4.0; do { /* TO FUNCTIONALIZE */ rand = g_random_int_range(0, count); if(gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store_library), &iter)) { for(i = 0; i < rand - 1; ++i) { gtk_tree_model_iter_next(GTK_TREE_MODEL(store_library), &iter); } gtk_tree_model_get(GTK_TREE_MODEL(store_library), &iter, FORCE_AMP, &rand_force_vector.amplitude, FORCE_ATK, &rand_force_vector.attack, FORCE_FREQ, &rand_force_vector.frequency, FORCE_TEMPO, &rand_force_vector.tempo, -1); } treshold -= 0.01; treshold_distance += 0.01; } while((bl_cosine_similarity(rand_force_vector, force_vector) < treshold) || ((distance = bl_distance(rand_force_vector, force_vector)) > treshold_distance)); gtk_tree_model_get(GTK_TREE_MODEL(store_library), &iter, AFILE, &remote_file, INET_ADDRESS, &player_with_the_song_char, -1); player_with_the_song = g_inet_address_new_from_string(player_with_the_song_char); if(g_inet_address_equal(player_with_the_song, inet_address) == TRUE) { rand_force_vector.attack = rand_force_vector.frequency = rand_force_vector.tempo = rand_force_vector.amplitude = 0; player_client = g_socket_client_new(); connection = g_socket_client_connect_to_host(player_client, g_inet_address_to_string(inet_address), 5353, NULL, NULL); output_stream = g_io_stream_get_output_stream(G_IO_STREAM(connection)); g_output_stream_write_all(output_stream, &rand_force_vector, sizeof(rand_force_vector), &count, NULL, NULL); g_io_stream_close(G_IO_STREAM(connection), NULL, NULL); g_socket_listener_accept_async(G_SOCKET_LISTENER(listener), NULL, lllp_next_song_cb, store_library); return; } player_client = g_socket_client_new(); connection = g_socket_client_connect_to_host(player_client, g_inet_address_to_string(inet_address), 5353, NULL, NULL); output_stream = g_io_stream_get_output_stream(G_IO_STREAM(connection)); g_output_stream_write_all(output_stream, &rand_force_vector, sizeof(rand_force_vector), &count, NULL, NULL); g_io_stream_close(G_IO_STREAM(connection), NULL, NULL); player_with_the_song_char = g_inet_address_to_string(player_with_the_song); connection = g_socket_client_connect_to_host(player_client, player_with_the_song_char, 19144, NULL, NULL); printf("%p\n", connection); output_stream = g_io_stream_get_output_stream(G_IO_STREAM(connection)); count = strlen(g_inet_address_to_string(inet_address)) + 1; g_output_stream_write_all(output_stream, &count, sizeof(gsize), NULL, NULL, NULL); g_output_stream_write_all(output_stream, g_inet_address_to_string(inet_address), count, NULL, NULL, NULL); count = strlen(remote_file) + 1; g_output_stream_write_all(output_stream, &count, sizeof(gsize), NULL, NULL, NULL); g_output_stream_write_all(output_stream, remote_file, count, NULL, NULL, NULL); g_output_stream_close(output_stream, NULL, NULL); g_socket_listener_accept_async(G_SOCKET_LISTENER(listener), NULL, lllp_next_song_cb, store_library); }
static void handle_player_enrol_message (SnraClient * client, GstStructure * s) { int clock_port; gint64 tmp; GstClockTime cur_time; gchar *server_ip_str = NULL; gdouble new_vol; if (!snra_json_structure_get_int (s, "clock-port", &clock_port)) return; /* Invalid message */ if (!snra_json_structure_get_int64 (s, "current-time", &tmp)) return; /* Invalid message */ cur_time = (GstClockTime) (tmp); if (snra_json_structure_get_double (s, "volume-level", &new_vol)) { if (client->player == NULL) construct_player (client); if (client->player) { //g_print ("New volume %g\n", new_vol); g_object_set (G_OBJECT (client->player), "volume", new_vol, "mute", (gboolean) (new_vol == 0.0), NULL); } } snra_json_structure_get_boolean (s, "enabled", &client->enabled); snra_json_structure_get_boolean (s, "paused", &client->paused); #if GLIB_CHECK_VERSION(2,22,0) { GResolver *resolver = g_resolver_get_default (); GList *names; if (resolver == NULL) return; names = g_resolver_lookup_by_name (resolver, client->connected_server, NULL, NULL); if (names) { server_ip_str = g_inet_address_to_string ((GInetAddress *) (names->data)); g_resolver_free_addresses (names); } g_object_unref (resolver); } #else { struct addrinfo *names = NULL; if (getaddrinfo (client->connected_server, NULL, NULL, &names)) return; if (names) { char hbuf[NI_MAXHOST]; if (getnameinfo (names->ai_addr, names->ai_addrlen, hbuf, sizeof (hbuf), NULL, 0, NI_NUMERICHOST) == 0) { server_ip_str = g_strdup (hbuf); } freeaddrinfo (names); } } #endif if (server_ip_str) { g_print ("Creating net clock at %s:%d time %" GST_TIME_FORMAT "\n", server_ip_str, clock_port, GST_TIME_ARGS (cur_time)); if (client->net_clock) gst_object_unref (client->net_clock); client->net_clock = gst_net_client_clock_new ("net_clock", server_ip_str, clock_port, cur_time); g_free (server_ip_str); } g_object_notify (G_OBJECT (client), "enabled"); g_object_notify (G_OBJECT (client), "paused"); }
static void arv_gv_interface_receive_hello_packet (ArvGvInterface *gv_interface) { GPollFD *poll_fd; GSList *iter; char buffer[ARV_GV_INTERFACE_SOCKET_BUFFER_SIZE]; int count; int i; if (gv_interface->priv->n_discover_infos ==0) return; poll_fd = g_new (GPollFD, gv_interface->priv->n_discover_infos); for (i = 0, iter = gv_interface->priv->discover_infos_list; iter != NULL; i++, iter = iter->next) { ArvGvInterfaceDiscoverInfos *infos = iter->data; poll_fd[i].fd = g_socket_get_fd (infos->socket); poll_fd[i].events = G_IO_IN; poll_fd[i].revents = 0; } do { if (g_poll (poll_fd, gv_interface->priv->n_discover_infos, ARV_GV_INTERFACE_DISCOVERY_TIMEOUT_MS) == 0) { g_free (poll_fd); return; } for (i = 0, iter = gv_interface->priv->discover_infos_list; iter != NULL; i++, iter = iter->next) { ArvGvInterfaceDiscoverInfos *infos = iter->data; do { g_socket_set_blocking (infos->socket, FALSE); count = g_socket_receive (infos->socket, buffer, ARV_GV_INTERFACE_SOCKET_BUFFER_SIZE, NULL, NULL); g_socket_set_blocking (infos->socket, TRUE); if (count > 0) { ArvGvcpPacket *packet = (ArvGvcpPacket *) buffer; if (g_ntohs (packet->header.command) == ARV_GVCP_COMMAND_DISCOVERY_ACK && g_ntohs (packet->header.id) == 0xffff) { ArvGvInterfaceDeviceInfos *device_infos; GInetAddress *interface_address; char *address_string; char *data = buffer + sizeof (ArvGvcpHeader); char *serial_number; char *manufacturer; char *key; arv_gvcp_packet_debug (packet, ARV_DEBUG_LEVEL_LOG); manufacturer = g_strndup (&data[ARV_GVBS_MANUFACTURER_NAME_OFFSET], ARV_GVBS_MANUFACTURER_NAME_SIZE); serial_number = g_strndup (&data[ARV_GVBS_SERIAL_NUMBER_OFFSET], ARV_GVBS_SERIAL_NUMBER_SIZE); key = g_strdup_printf ("%s-%s", manufacturer, serial_number); g_free (manufacturer); g_free (serial_number); interface_address = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (infos->interface_address)); device_infos = arv_gv_interface_device_infos_new (interface_address, data); address_string = g_inet_address_to_string (interface_address); arv_debug_interface ("[GvInterface::discovery] Device '%s' found " "(interface %s)", key, address_string); g_free (address_string); g_hash_table_insert (gv_interface->priv->devices, key, device_infos); g_hash_table_insert (gv_interface->priv->devices_by_mac, device_infos->mac_string, device_infos); } } } while (count > 0); } } while (1); }
void * arv_fake_gv_camera_thread (void *user_data) { ArvFakeGvCamera *gv_camera = user_data; ArvBuffer *image_buffer = NULL; GError *error = NULL; GSocketAddress *stream_address = NULL; void *packet_buffer; size_t packet_size; size_t payload = 0; guint16 block_id; ptrdiff_t offset; guint32 gv_packet_size; packet_buffer = g_malloc (ARV_FAKE_GV_CAMERA_BUFFER_SIZE); do { if (arv_fake_camera_get_control_channel_privilege (gv_camera->camera) == 0 || arv_fake_camera_get_acquisition_status (gv_camera->camera) == 0) { if (stream_address != NULL) { g_object_unref (stream_address); stream_address = NULL; g_object_unref (image_buffer); image_buffer = NULL; arv_debug_stream_thread ("[FakeGvCamera::stream_thread] Stop stream"); } g_usleep (100000); } else { if (stream_address == NULL) { GInetAddress *inet_address; char *inet_address_string; stream_address = arv_fake_camera_get_stream_address (gv_camera->camera); inet_address = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (stream_address)); inet_address_string = g_inet_address_to_string (inet_address); arv_debug_stream_thread ("[FakeGvCamera::stream_thread] Start stream to %s (%d)", inet_address_string, g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (stream_address))); g_free (inet_address_string); payload = arv_fake_camera_get_payload (gv_camera->camera); image_buffer = arv_buffer_new (payload, NULL); } arv_fake_camera_wait_for_next_frame (gv_camera->camera); arv_fake_camera_fill_buffer (gv_camera->camera, image_buffer, &gv_packet_size); block_id = 0; packet_size = ARV_FAKE_GV_CAMERA_BUFFER_SIZE; arv_gvsp_packet_new_data_leader (image_buffer->frame_id, block_id, image_buffer->timestamp_ns, image_buffer->pixel_format, image_buffer->width, image_buffer->height, image_buffer->x_offset, image_buffer->y_offset, packet_buffer, &packet_size); g_socket_send_to (gv_camera->gvsp_socket, stream_address, packet_buffer, packet_size, NULL, &error); if (error != NULL) { arv_warning_stream_thread ("[ArvFakeGvCamera::stream_thread] Socket send error [%s]", error->message); g_error_free (error); error = NULL; } block_id++; offset = 0; while (offset < payload) { size_t data_size; data_size = MIN (gv_packet_size - ARV_GVSP_PACKET_PROTOCOL_OVERHEAD, payload - offset); packet_size = ARV_FAKE_GV_CAMERA_BUFFER_SIZE; arv_gvsp_packet_new_data_block (image_buffer->frame_id, block_id, data_size, ((char *) image_buffer->data) + offset, packet_buffer, &packet_size); g_socket_send_to (gv_camera->gvsp_socket, stream_address, packet_buffer, packet_size, NULL, NULL); offset += data_size; block_id++; } packet_size = ARV_FAKE_GV_CAMERA_BUFFER_SIZE; arv_gvsp_packet_new_data_trailer (image_buffer->frame_id, block_id, packet_buffer, &packet_size); g_socket_send_to (gv_camera->gvsp_socket, stream_address, packet_buffer, packet_size, NULL, NULL); } } while (!cancel); if (stream_address != NULL) g_object_unref (stream_address); if (image_buffer != NULL) g_object_unref (image_buffer); g_free (packet_buffer); return NULL; }
//Read tcp requests of connected clients gboolean network_read(GIOChannel *source, GIOCondition cond, gpointer data) { GString *s = g_string_new(NULL); GError *error = NULL; GIOStatus ret = g_io_channel_read_line_string(source, s, NULL, &error); if (ret == G_IO_STATUS_ERROR) { //unref connection GSocketAddress *sockaddr = g_socket_connection_get_remote_address(data, NULL); GInetAddress *addr = g_inet_socket_address_get_address(G_INET_SOCKET_ADDRESS(sockaddr)); //Read sender ip if (verbose) { printf("App Server: Communication error.. Removing client.. ->%s\n", g_inet_address_to_string(addr)); fflush(stdout); } //Remove client remove_client(g_inet_address_to_string(addr)); //Free objects g_string_free(s, TRUE); g_object_unref(sockaddr); g_object_unref(addr); g_object_unref(data); //Return false to stop listening this socket return FALSE; } else{ //Read request command gchar *RecString; RecString=s->str; //check client password if ((strncmp(RecString, AppPass, strlen(AppPass))) == 0) { //Password ok can send command GString *incs = g_string_new(s->str); incs = g_string_erase(s,0,(strlen(AppPass)+1)); IvySendMsg("%s",incs->str); if (verbose) { printf("App Server: Command passed to ivy: %s\n",incs->str); fflush(stdout); } } //AC data request. (Ignore client password) else if ((strncmp(RecString, "getac ", strlen("getac "))) == 0) { //AC data request char AcData[BUFLEN]; //Read ac data if (get_ac_data(RecString, AcData)) { //Send requested data to client GOutputStream * ostream = g_io_stream_get_output_stream (data); g_output_stream_write(ostream, AcData, strlen(AcData), NULL, &error); } } //Waypoint data request (Ignore client password) else if ((strncmp(RecString, "getwp ", strlen("getwp "))) == 0) { char AcData[BUFLEN]; //Read wp data of ac if (get_wp_data(RecString, AcData)) { //Send requested data to client GOutputStream * ostream = g_io_stream_get_output_stream (data); g_output_stream_write(ostream, AcData, strlen(AcData), NULL, &error); } } //Waypoint data request (Ignore client password) else if ((strncmp(RecString, "getbl ", strlen("getbl "))) == 0) { char AcData[BUFLEN]; //Read block data of AC if (get_bl_data(RecString, AcData)) { //Send requested data to client GOutputStream * ostream = g_io_stream_get_output_stream (data); g_output_stream_write(ostream, AcData, strlen(AcData), NULL, &error); } } //If client sends removeme command, remove it from broadcast list else if ((strncmp( RecString, "removeme", strlen("removeme"))) == 0) { GSocketAddress *sockaddr = g_socket_connection_get_remote_address(data, NULL); GInetAddress *addr = g_inet_socket_address_get_address(G_INET_SOCKET_ADDRESS(sockaddr)); //Read sender ip if (verbose) { printf("App Server: need to remove %s\n", g_inet_address_to_string(addr)); fflush(stdout); } //Remove client remove_client(g_inet_address_to_string(addr)); //Free objects g_string_free(s, TRUE); g_object_unref(sockaddr); g_object_unref(addr); g_object_unref(data); //Return false to stop listening this socket return FALSE; } else { //Unknown command if (verbose) { printf("App Server: Client send an unknown command or wrong password: (%s)\n",RecString); fflush(stdout); } } } if (ret == G_IO_STATUS_EOF) { //Client disconnected if (verbose) { GSocketAddress *sockaddr = g_socket_connection_get_remote_address(data, NULL); GInetAddress *addr = g_inet_socket_address_get_address(G_INET_SOCKET_ADDRESS(sockaddr)); printf("App Server: Client disconnected without saying 'bye':( ->%s\n", g_inet_address_to_string(addr)); remove_client(g_inet_address_to_string(addr)); fflush(stdout); } g_string_free(s, TRUE); //Unref the socket and return false to allow the client to reconnect g_object_unref(data); return FALSE; } //None above.. Keep listening the socket g_string_free(s, TRUE); return TRUE; }
static void return_result (GTask *task) { GProxyAddressEnumeratorPrivate *priv = g_task_get_task_data (task); GSocketAddress *result; if (strcmp ("direct", priv->proxy_type) == 0) { result = priv->proxy_address; priv->proxy_address = NULL; } else { gchar *dest_hostname, *dest_protocol; GInetSocketAddress *inetsaddr; GInetAddress *inetaddr; guint16 port; if (!priv->supports_hostname) { GInetAddress *dest_ip; if (!priv->next_dest_ip) priv->next_dest_ip = priv->dest_ips; dest_ip = G_INET_ADDRESS (priv->next_dest_ip->data); dest_hostname = g_inet_address_to_string (dest_ip); priv->next_dest_ip = g_list_next (priv->next_dest_ip); } else { dest_hostname = g_strdup (priv->dest_hostname); } dest_protocol = g_uri_parse_scheme (priv->dest_uri); g_return_if_fail (G_IS_INET_SOCKET_ADDRESS (priv->proxy_address)); inetsaddr = G_INET_SOCKET_ADDRESS (priv->proxy_address); inetaddr = g_inet_socket_address_get_address (inetsaddr); port = g_inet_socket_address_get_port (inetsaddr); result = g_object_new (G_TYPE_PROXY_ADDRESS, "address", inetaddr, "port", port, "protocol", priv->proxy_type, "destination-protocol", dest_protocol, "destination-hostname", dest_hostname, "destination-port", priv->dest_port, "username", priv->proxy_username, "password", priv->proxy_password, "uri", priv->proxy_uri, NULL); g_free (dest_hostname); g_free (dest_protocol); if (priv->supports_hostname || priv->next_dest_ip == NULL) { g_object_unref (priv->proxy_address); priv->proxy_address = NULL; } } g_task_return_pointer (task, result, g_object_unref); g_object_unref (task); }
void * _thread (void *user_data) { ArvGvFakeCamera *gv_fake_camera = user_data; ArvBuffer *image_buffer = NULL; GError *error = NULL; GSocketAddress *stream_address = NULL; void *packet_buffer; size_t packet_size; size_t payload = 0; guint16 block_id; ptrdiff_t offset; guint32 gv_packet_size; GInputVector input_vector; int n_events; gboolean is_streaming = FALSE; input_vector.buffer = g_malloc0 (ARV_GV_FAKE_CAMERA_BUFFER_SIZE); input_vector.size = ARV_GV_FAKE_CAMERA_BUFFER_SIZE; packet_buffer = g_malloc (ARV_GV_FAKE_CAMERA_BUFFER_SIZE); do { guint64 next_timestamp_us; guint64 sleep_time_us; if (is_streaming) { sleep_time_us = arv_fake_camera_get_sleep_time_for_next_frame (gv_fake_camera->priv->camera, &next_timestamp_us); } else { sleep_time_us = 100000; next_timestamp_us = g_get_real_time () + sleep_time_us; } do { gint timeout_ms; timeout_ms = MIN (100, (next_timestamp_us - g_get_real_time ()) / 1000LL); if (timeout_ms < 0) timeout_ms = 0; n_events = g_poll (gv_fake_camera->priv->gvcp_fds, 2, timeout_ms); if (n_events > 0) { GSocketAddress *remote_address = NULL; int count; count = g_socket_receive_message (gv_fake_camera->priv->gvcp_socket, &remote_address, &input_vector, 1, NULL, NULL, NULL, NULL, NULL); if (count > 0) { if (handle_control_packet (gv_fake_camera, gv_fake_camera->priv->gvcp_socket, remote_address, input_vector.buffer, count)) arv_debug_device ("[GvFakeCamera::thread] Control packet received"); } g_clear_object (&remote_address); if (gv_fake_camera->priv->discovery_socket != NULL) { count = g_socket_receive_message (gv_fake_camera->priv->discovery_socket, &remote_address, &input_vector, 1, NULL, NULL, NULL, NULL, NULL); if (count > 0) { if (handle_control_packet (gv_fake_camera, gv_fake_camera->priv->discovery_socket, remote_address, input_vector.buffer, count)) arv_debug_device ("[GvFakeCamera::thread]" " Control packet received on discovery socket\n"); } g_clear_object (&remote_address); } if (arv_fake_camera_get_control_channel_privilege (gv_fake_camera->priv->camera) == 0 || arv_fake_camera_get_acquisition_status (gv_fake_camera->priv->camera) == 0) { if (stream_address != NULL) { g_object_unref (stream_address); stream_address = NULL; g_object_unref (image_buffer); image_buffer = NULL; arv_debug_stream_thread ("[GvFakeCamera::thread] Stop stream"); } is_streaming = FALSE; } } } while (!g_atomic_int_get (&gv_fake_camera->priv->cancel) && g_get_real_time () < next_timestamp_us); if (arv_fake_camera_get_control_channel_privilege (gv_fake_camera->priv->camera) != 0 && arv_fake_camera_get_acquisition_status (gv_fake_camera->priv->camera) != 0) { if (stream_address == NULL) { GInetAddress *inet_address; char *inet_address_string; stream_address = arv_fake_camera_get_stream_address (gv_fake_camera->priv->camera); inet_address = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (stream_address)); inet_address_string = g_inet_address_to_string (inet_address); arv_debug_stream_thread ("[GvFakeCamera::thread] Start stream to %s (%d)", inet_address_string, g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (stream_address))); g_free (inet_address_string); payload = arv_fake_camera_get_payload (gv_fake_camera->priv->camera); image_buffer = arv_buffer_new (payload, NULL); } arv_fake_camera_fill_buffer (gv_fake_camera->priv->camera, image_buffer, &gv_packet_size); arv_debug_stream_thread ("[GvFakeCamera::thread] Send frame %d", image_buffer->priv->frame_id); block_id = 0; packet_size = ARV_GV_FAKE_CAMERA_BUFFER_SIZE; arv_gvsp_packet_new_data_leader (image_buffer->priv->frame_id, block_id, image_buffer->priv->timestamp_ns, image_buffer->priv->pixel_format, image_buffer->priv->width, image_buffer->priv->height, image_buffer->priv->x_offset, image_buffer->priv->y_offset, packet_buffer, &packet_size); g_socket_send_to (gv_fake_camera->priv->gvsp_socket, stream_address, packet_buffer, packet_size, NULL, &error); if (error != NULL) { arv_warning_stream_thread ("[GvFakeCamera::thread] Failed to send leader for frame %d: %s", image_buffer->priv->frame_id, error->message); g_clear_error (&error); } block_id++; offset = 0; while (offset < payload) { size_t data_size; data_size = MIN (gv_packet_size - ARV_GVSP_PACKET_PROTOCOL_OVERHEAD, payload - offset); packet_size = ARV_GV_FAKE_CAMERA_BUFFER_SIZE; arv_gvsp_packet_new_data_block (image_buffer->priv->frame_id, block_id, data_size, ((char *) image_buffer->priv->data) + offset, packet_buffer, &packet_size); g_socket_send_to (gv_fake_camera->priv->gvsp_socket, stream_address, packet_buffer, packet_size, NULL, &error); if (error != NULL) { arv_debug_stream_thread ("[GvFakeCamera::thread] Failed to send frame block %d for frame: %s", block_id, image_buffer->priv->frame_id, error->message); g_clear_error (&error); } offset += data_size; block_id++; } packet_size = ARV_GV_FAKE_CAMERA_BUFFER_SIZE; arv_gvsp_packet_new_data_trailer (image_buffer->priv->frame_id, block_id, packet_buffer, &packet_size); g_socket_send_to (gv_fake_camera->priv->gvsp_socket, stream_address, packet_buffer, packet_size, NULL, &error); if (error != NULL) { arv_debug_stream_thread ("[GvFakeCamera::thread] Failed to send trailer for frame %d: %s", image_buffer->priv->frame_id, error->message); g_clear_error (&error); } is_streaming = TRUE; } } while (!g_atomic_int_get (&gv_fake_camera->priv->cancel)); if (stream_address != NULL) g_object_unref (stream_address); if (image_buffer != NULL) g_object_unref (image_buffer); g_free (packet_buffer); g_free (input_vector.buffer); return NULL; }
/* create a socket for sending to remote machine */ static gboolean gst_udpsrc_start (GstBaseSrc * bsrc) { GstUDPSrc *src; GInetAddress *addr, *bind_addr; GSocketAddress *bind_saddr; GResolver *resolver; GError *err = NULL; src = GST_UDPSRC (bsrc); if (src->socket == NULL) { /* need to allocate a socket */ GST_DEBUG_OBJECT (src, "allocating socket for %s:%d", src->host, src->port); addr = g_inet_address_new_from_string (src->host); if (!addr) { GList *results; GST_DEBUG_OBJECT (src, "resolving IP address for host %s", src->host); resolver = g_resolver_get_default (); results = g_resolver_lookup_by_name (resolver, src->host, src->cancellable, &err); if (!results) goto name_resolve; addr = G_INET_ADDRESS (g_object_ref (results->data)); g_resolver_free_addresses (results); g_object_unref (resolver); } #ifndef GST_DISABLE_GST_DEBUG { gchar *ip = g_inet_address_to_string (addr); GST_DEBUG_OBJECT (src, "IP address for host %s is %s", src->host, ip); g_free (ip); } #endif if ((src->used_socket = g_socket_new (g_inet_address_get_family (addr), G_SOCKET_TYPE_DATAGRAM, G_SOCKET_PROTOCOL_UDP, &err)) == NULL) goto no_socket; src->external_socket = FALSE; GST_DEBUG_OBJECT (src, "got socket %p", src->used_socket); if (src->addr) g_object_unref (src->addr); src->addr = G_INET_SOCKET_ADDRESS (g_inet_socket_address_new (addr, src->port)); GST_DEBUG_OBJECT (src, "binding on port %d", src->port); if (g_inet_address_get_is_multicast (addr)) bind_addr = g_inet_address_new_any (g_inet_address_get_family (addr)); else bind_addr = G_INET_ADDRESS (g_object_ref (addr)); g_object_unref (addr); bind_saddr = g_inet_socket_address_new (bind_addr, src->port); g_object_unref (bind_addr); if (!g_socket_bind (src->used_socket, bind_saddr, src->reuse, &err)) goto bind_error; g_object_unref (bind_saddr); } else { GST_DEBUG_OBJECT (src, "using provided socket %p", src->socket); /* we use the configured socket, try to get some info about it */ src->used_socket = G_SOCKET (g_object_ref (src->socket)); src->external_socket = TRUE; if (src->addr) g_object_unref (src->addr); src->addr = G_INET_SOCKET_ADDRESS (g_socket_get_local_address (src->used_socket, &err)); if (!src->addr) goto getsockname_error; } #if GLIB_CHECK_VERSION (2, 35, 7) { gint val = 0; if (src->buffer_size != 0) { GError *opt_err = NULL; GST_INFO_OBJECT (src, "setting udp buffer of %d bytes", src->buffer_size); /* set buffer size, Note that on Linux this is typically limited to a * maximum of around 100K. Also a minimum of 128 bytes is required on * Linux. */ if (!g_socket_set_option (src->used_socket, SOL_SOCKET, SO_RCVBUF, src->buffer_size, &opt_err)) { GST_ELEMENT_WARNING (src, RESOURCE, SETTINGS, (NULL), ("Could not create a buffer of requested %d bytes: %s", src->buffer_size, opt_err->message)); g_error_free (opt_err); opt_err = NULL; } } /* read the value of the receive buffer. Note that on linux this returns * 2x the value we set because the kernel allocates extra memory for * metadata. The default on Linux is about 100K (which is about 50K * without metadata) */ if (g_socket_get_option (src->used_socket, SOL_SOCKET, SO_RCVBUF, &val, NULL)) { GST_INFO_OBJECT (src, "have udp buffer of %d bytes", val); } else { GST_DEBUG_OBJECT (src, "could not get udp buffer size"); } } #elif defined (SO_RCVBUF) { gint rcvsize, ret; socklen_t len; len = sizeof (rcvsize); if (src->buffer_size != 0) { rcvsize = src->buffer_size; GST_DEBUG_OBJECT (src, "setting udp buffer of %d bytes", rcvsize); /* set buffer size, Note that on Linux this is typically limited to a * maximum of around 100K. Also a minimum of 128 bytes is required on * Linux. */ ret = setsockopt (g_socket_get_fd (src->used_socket), SOL_SOCKET, SO_RCVBUF, (void *) &rcvsize, len); if (ret != 0) { GST_ELEMENT_WARNING (src, RESOURCE, SETTINGS, (NULL), ("Could not create a buffer of requested %d bytes, %d: %s (%d)", rcvsize, ret, g_strerror (errno), errno)); } } /* read the value of the receive buffer. Note that on linux this returns 2x the * value we set because the kernel allocates extra memory for metadata. * The default on Linux is about 100K (which is about 50K without metadata) */ ret = getsockopt (g_socket_get_fd (src->used_socket), SOL_SOCKET, SO_RCVBUF, (void *) &rcvsize, &len); if (ret == 0) GST_DEBUG_OBJECT (src, "have udp buffer of %d bytes", rcvsize); else GST_DEBUG_OBJECT (src, "could not get udp buffer size"); } #else if (src->buffer_size != 0) { GST_WARNING_OBJECT (src, "don't know how to set udp buffer size on this " "OS. Consider upgrading your GLib to >= 2.35.7 and re-compiling the " "GStreamer udp plugin"); } #endif g_socket_set_broadcast (src->used_socket, TRUE); if (src->auto_multicast && g_inet_address_get_is_multicast (g_inet_socket_address_get_address (src->addr))) { GST_DEBUG_OBJECT (src, "joining multicast group %s", src->host); if (!g_socket_join_multicast_group (src->used_socket, g_inet_socket_address_get_address (src->addr), FALSE, src->multi_iface, &err)) goto membership; } /* NOTE: sockaddr_in.sin_port works for ipv4 and ipv6 because sin_port * follows ss_family on both */ { GInetSocketAddress *addr; guint16 port; addr = G_INET_SOCKET_ADDRESS (g_socket_get_local_address (src->used_socket, &err)); if (!addr) goto getsockname_error; port = g_inet_socket_address_get_port (addr); GST_DEBUG_OBJECT (src, "bound, on port %d", port); if (port != src->port) { src->port = port; GST_DEBUG_OBJECT (src, "notifying port %d", port); g_object_notify (G_OBJECT (src), "port"); } g_object_unref (addr); } return TRUE; /* ERRORS */ name_resolve: { GST_ELEMENT_ERROR (src, RESOURCE, SETTINGS, (NULL), ("Name resolval failed: %s", err->message)); g_clear_error (&err); g_object_unref (resolver); return FALSE; } no_socket: { GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL), ("no socket error: %s", err->message)); g_clear_error (&err); g_object_unref (addr); return FALSE; } bind_error: { GST_ELEMENT_ERROR (src, RESOURCE, SETTINGS, (NULL), ("bind failed: %s", err->message)); g_clear_error (&err); g_object_unref (bind_saddr); gst_udpsrc_stop (GST_BASE_SRC (src)); return FALSE; } membership: { GST_ELEMENT_ERROR (src, RESOURCE, SETTINGS, (NULL), ("could add membership: %s", err->message)); g_clear_error (&err); gst_udpsrc_stop (GST_BASE_SRC (src)); return FALSE; } getsockname_error: { GST_ELEMENT_ERROR (src, RESOURCE, SETTINGS, (NULL), ("getsockname failed: %s", err->message)); g_clear_error (&err); gst_udpsrc_stop (GST_BASE_SRC (src)); return FALSE; } }
static VALUE rg_to_string(VALUE self) { return CSTR2RVAL_FREE(g_inet_address_to_string(_SELF(self))); }
/* set up server */ static gboolean gst_tcp_server_src_start (GstBaseSrc * bsrc) { GstTCPServerSrc *src = GST_TCP_SERVER_SRC (bsrc); GError *err = NULL; GInetAddress *addr; GSocketAddress *saddr; GResolver *resolver; /* look up name if we need to */ addr = g_inet_address_new_from_string (src->host); if (!addr) { GList *results; resolver = g_resolver_get_default (); results = g_resolver_lookup_by_name (resolver, src->host, src->cancellable, &err); if (!results) goto name_resolve; addr = G_INET_ADDRESS (g_object_ref (results->data)); g_resolver_free_addresses (results); g_object_unref (resolver); } #ifndef GST_DISABLE_GST_DEBUG { gchar *ip = g_inet_address_to_string (addr); GST_DEBUG_OBJECT (src, "IP address for host %s is %s", src->host, ip); g_free (ip); } #endif saddr = g_inet_socket_address_new (addr, src->server_port); g_object_unref (addr); /* create the server listener socket */ src->server_socket = g_socket_new (g_socket_address_get_family (saddr), G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_TCP, &err); if (!src->server_socket) goto no_socket; GST_DEBUG_OBJECT (src, "opened receiving server socket"); /* bind it */ GST_DEBUG_OBJECT (src, "binding server socket to address"); if (!g_socket_bind (src->server_socket, saddr, TRUE, &err)) goto bind_failed; g_object_unref (saddr); GST_DEBUG_OBJECT (src, "listening on server socket"); g_socket_set_listen_backlog (src->server_socket, TCP_BACKLOG); if (!g_socket_listen (src->server_socket, &err)) goto listen_failed; GST_OBJECT_FLAG_SET (src, GST_TCP_SERVER_SRC_OPEN); return TRUE; /* ERRORS */ no_socket: { GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL), ("Failed to create socket: %s", err->message)); g_clear_error (&err); g_object_unref (saddr); return FALSE; } name_resolve: { if (g_error_matches (err, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { GST_DEBUG_OBJECT (src, "Cancelled name resolval"); } else { GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL), ("Failed to resolve host '%s': %s", src->host, err->message)); } g_clear_error (&err); g_object_unref (resolver); return FALSE; } bind_failed: { if (g_error_matches (err, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { GST_DEBUG_OBJECT (src, "Cancelled binding"); } else { GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL), ("Failed to bind on host '%s:%d': %s", src->host, src->server_port, err->message)); } g_clear_error (&err); g_object_unref (saddr); gst_tcp_server_src_stop (GST_BASE_SRC (src)); return FALSE; } listen_failed: { if (g_error_matches (err, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { GST_DEBUG_OBJECT (src, "Cancelled listening"); } else { GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL), ("Failed to listen on host '%s:%d': %s", src->host, src->server_port, err->message)); } g_clear_error (&err); gst_tcp_server_src_stop (GST_BASE_SRC (src)); return FALSE; } }
static void synce_device_set_property (GObject *obj, guint property_id, const GValue *value, GParamSpec *pspec) { SynceDevice *self = SYNCE_DEVICE (obj); SynceDevicePrivate *priv = SYNCE_DEVICE_GET_PRIVATE (self); switch (property_id) { case PROP_CONNECTION: if (priv->conn != NULL) { g_object_unref (priv->conn); } priv->conn = g_value_get_pointer (value); g_object_ref (priv->conn); GInputStream *in_stream = g_io_stream_get_input_stream(G_IO_STREAM(priv->conn)); priv->iobuf = g_malloc(sizeof (guint32)); g_input_stream_read_async(in_stream, priv->iobuf, sizeof (guint32), G_PRIORITY_DEFAULT, NULL, synce_device_conn_event_cb, g_object_ref(self)); GInetSocketAddress *address = NULL; GInetAddress *inet_address = NULL; address = G_INET_SOCKET_ADDRESS(g_socket_connection_get_remote_address(priv->conn, NULL)); inet_address = g_inet_socket_address_get_address(address); priv->ip_address = g_inet_address_to_string(inet_address); g_object_unref(address); address = G_INET_SOCKET_ADDRESS(g_socket_connection_get_local_address(priv->conn, NULL)); inet_address = g_inet_socket_address_get_address(address); priv->iface_address = g_inet_address_to_string(inet_address); g_object_unref(address); break; case PROP_DEVICE_PATH: g_free (priv->device_path); priv->device_path = g_value_dup_string (value); g_debug("%s: running for device %s", G_STRFUNC, priv->device_path); break; case PROP_OBJ_PATH: g_free (priv->obj_path); priv->obj_path = g_value_dup_string (value); break; case PROP_GUID: g_free (priv->guid); priv->guid = g_value_dup_string (value); break; case PROP_OS_MAJOR: priv->os_major = g_value_get_uint (value); break; case PROP_OS_MINOR: priv->os_minor = g_value_get_uint (value); break; case PROP_NAME: g_free (priv->name); priv->name = g_value_dup_string (value); break; case PROP_VERSION: priv->version = g_value_get_uint (value); break; case PROP_CPU_TYPE: priv->cpu_type = g_value_get_uint (value); break; case PROP_CURRENT_PARTNER_ID: priv->cur_partner_id = g_value_get_uint (value); break; case PROP_ID: priv->id = g_value_get_uint (value); break; case PROP_PLATFORM_NAME: g_free (priv->platform_name); priv->platform_name = g_value_dup_string (value); break; case PROP_MODEL_NAME: g_free (priv->model_name); priv->model_name = g_value_dup_string (value); break; case PROP_PASSWORD_FLAGS: priv->pw_flags = g_value_get_uint (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, property_id, pspec); break; } }
static gboolean gssdp_socket_source_do_init (GInitable *initable, G_GNUC_UNUSED GCancellable *cancellable, GError **error) { GSSDPSocketSource *self = NULL; GInetAddress *iface_address = NULL; GSocketAddress *bind_address = NULL; GInetAddress *group = NULL; GError *inner_error = NULL; GSocketFamily family; gboolean success = FALSE; self = GSSDP_SOCKET_SOURCE (initable); iface_address = g_inet_address_new_from_string (self->priv->host_ip); if (iface_address == NULL) { g_set_error (error, GSSDP_ERROR, GSSDP_ERROR_FAILED, "Invalid host ip: %s", self->priv->host_ip); goto error; } family = g_inet_address_get_family (iface_address); if (family == G_SOCKET_FAMILY_IPV4) group = g_inet_address_new_from_string (SSDP_ADDR); else { g_set_error_literal (error, GSSDP_ERROR, GSSDP_ERROR_FAILED, "IPv6 address"); goto error; } /* Create socket */ self->priv->socket = g_socket_new (G_SOCKET_FAMILY_IPV4, G_SOCKET_TYPE_DATAGRAM, G_SOCKET_PROTOCOL_UDP, &inner_error); if (!self->priv->socket) { g_propagate_prefixed_error (error, inner_error, "Could not create socket"); goto error; } /* Enable broadcasting */ if (!gssdp_socket_enable_broadcast (self->priv->socket, TRUE, &inner_error)) { g_propagate_prefixed_error (error, inner_error, "Failed to enable broadcast"); goto error; } /* TTL */ if (!self->priv->ttl) /* UDA/1.0 says 4, UDA/1.1 says 2 */ self->priv->ttl = 4; if (!gssdp_socket_set_ttl (self->priv->socket, self->priv->ttl, &inner_error)) { g_propagate_prefixed_error (error, inner_error, "Failed to set TTL to %u", self->priv->ttl); goto error; } /* Set up additional things according to the type of socket desired */ if (self->priv->type == GSSDP_SOCKET_SOURCE_TYPE_MULTICAST) { /* Enable multicast loopback */ if (!gssdp_socket_enable_loop (self->priv->socket, TRUE, &inner_error)) { g_propagate_prefixed_error ( error, inner_error, "Failed to enable loop-back"); goto error; } if (!gssdp_socket_mcast_interface_set (self->priv->socket, iface_address, &inner_error)) { g_propagate_prefixed_error ( error, inner_error, "Failed to set multicast interface"); goto error; } #ifdef G_OS_WIN32 bind_address = g_inet_socket_address_new (iface_address, SSDP_PORT); #else bind_address = g_inet_socket_address_new (group, SSDP_PORT); #endif } else { guint port = SSDP_PORT; /* Use user-supplied or random port for the socket source used * by M-SEARCH */ if (self->priv->type == GSSDP_SOCKET_SOURCE_TYPE_SEARCH) port = self->priv->port; bind_address = g_inet_socket_address_new (iface_address, port); } /* Normally g_socket_bind does this, but it is disabled on * windows since SO_REUSEADDR has different semantics * there, also we nees SO_REUSEPORT on OpenBSD. This is a nop * everywhere else. */ if (!gssdp_socket_reuse_address (self->priv->socket, TRUE, &inner_error)) { g_propagate_prefixed_error ( error, inner_error, "Failed to enable reuse"); goto error; } /* Bind to requested port and address */ if (!g_socket_bind (self->priv->socket, bind_address, TRUE, &inner_error)) { g_propagate_prefixed_error (error, inner_error, "Failed to bind socket"); goto error; } if (self->priv->type == GSSDP_SOCKET_SOURCE_TYPE_MULTICAST) { /* Subscribe to multicast channel */ if (!gssdp_socket_mcast_group_join (self->priv->socket, group, iface_address, &inner_error)) { char *address = g_inet_address_to_string (group); g_propagate_prefixed_error (error, inner_error, "Failed to join group %s", address); g_free (address); goto error; } } self->priv->source = g_socket_create_source (self->priv->socket, G_IO_IN | G_IO_ERR, NULL); success = TRUE; error: if (iface_address != NULL) g_object_unref (iface_address); if (bind_address != NULL) g_object_unref (bind_address); if (group != NULL) g_object_unref (group); if (!success) /* Be aware that inner_error has already been free'd by * g_propagate_error(), so we cannot access its contents * anymore. */ if (error == NULL) g_warning ("Failed to create socket source"); return success; }
static void identd_read_ready (GDataInputStream *in_stream, GAsyncResult *res, ident_info *info) { GSocketAddress *sok_addr; GOutputStream *out_stream; guint64 local, remote; gchar *read_buf, buf[512], *p; if ((read_buf = g_data_input_stream_read_line_finish (in_stream, res, NULL, NULL))) { local = g_ascii_strtoull (read_buf, NULL, 0); p = strchr (read_buf, ','); if (!p) { g_free (read_buf); goto cleanup; } remote = g_ascii_strtoull (p + 1, NULL, 0); g_free (read_buf); g_snprintf (buf, sizeof (buf), "%"G_GUINT16_FORMAT", %"G_GUINT16_FORMAT" : ", (guint16)MIN(local, G_MAXUINT16), (guint16)MIN(remote, G_MAXUINT16)); if (!local || !remote || local > G_MAXUINT16 || remote > G_MAXUINT16) { g_strlcat (buf, "ERROR : INVALID-PORT\r\n", sizeof (buf)); g_debug ("Identd: Received invalid port"); } else { info->username = g_hash_table_lookup (responses, GINT_TO_POINTER (local)); if (!info->username) { g_strlcat (buf, "ERROR : NO-USER\r\n", sizeof (buf)); g_debug ("Identd: Received invalid local port"); } else { const gsize len = strlen (buf); g_hash_table_steal (responses, GINT_TO_POINTER (local)); g_snprintf (buf + len, sizeof (buf) - len, "USERID : UNIX : %s\r\n", info->username); if ((sok_addr = g_socket_connection_get_remote_address (info->conn, NULL))) { GInetAddress *inet_addr; gchar *addr; inet_addr = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (sok_addr)); addr = g_inet_address_to_string (inet_addr); hexchat_printf (ph, _("*\tServicing ident request from %s as %s"), addr, info->username); g_object_unref (sok_addr); g_object_unref (inet_addr); g_free (addr); } } } out_stream = g_io_stream_get_output_stream (G_IO_STREAM (info->conn)); g_output_stream_write_async (out_stream, buf, strlen (buf), G_PRIORITY_DEFAULT, NULL, (GAsyncReadyCallback)identd_write_ready, info); } return; cleanup: ident_info_free (info); }
static void arv_gv_interface_discover (ArvGvInterface *gv_interface) { ArvGvDiscoverSocketList *socket_list; GSList *iter; char buffer[ARV_GV_INTERFACE_SOCKET_BUFFER_SIZE]; int count; int i; socket_list = arv_gv_discover_socket_list_new (); if (socket_list->n_sockets < 1) { arv_gv_discover_socket_list_free (socket_list); return; } arv_gv_discover_socket_list_send_discover_packet (socket_list); do { if (g_poll (socket_list->poll_fds, socket_list->n_sockets, ARV_GV_INTERFACE_DISCOVERY_TIMEOUT_MS) == 0) { arv_gv_discover_socket_list_free (socket_list); return; } for (i = 0, iter = socket_list->sockets; iter != NULL; i++, iter = iter->next) { ArvGvDiscoverSocket *discover_socket = iter->data; do { g_socket_set_blocking (discover_socket->socket, FALSE); count = g_socket_receive (discover_socket->socket, buffer, ARV_GV_INTERFACE_SOCKET_BUFFER_SIZE, NULL, NULL); g_socket_set_blocking (discover_socket->socket, TRUE); if (count > 0) { ArvGvcpPacket *packet = (ArvGvcpPacket *) buffer; if (g_ntohs (packet->header.command) == ARV_GVCP_COMMAND_DISCOVERY_ACK && g_ntohs (packet->header.id) == 0xffff) { ArvGvInterfaceDeviceInfos *device_infos; GInetAddress *interface_address; char *address_string; char *data = buffer + sizeof (ArvGvcpHeader); arv_gvcp_packet_debug (packet, ARV_DEBUG_LEVEL_LOG); interface_address = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (discover_socket->interface_address)); device_infos = arv_gv_interface_device_infos_new (interface_address, data); address_string = g_inet_address_to_string (interface_address); arv_debug_interface ("[GvInterface::discovery] Device '%s' found " "(interface %s) user_name '%s' - MAC_name '%s'", device_infos->name, address_string, device_infos->user_name, device_infos->mac_string); g_free (address_string); if (device_infos->name != NULL && device_infos->name[0] != '\0') { arv_gv_interface_device_infos_ref (device_infos); g_hash_table_replace (gv_interface->priv->devices, device_infos->name, device_infos); } if (device_infos->user_name != NULL && device_infos->user_name[0] != '\0') { arv_gv_interface_device_infos_ref (device_infos); g_hash_table_replace (gv_interface->priv->devices, device_infos->user_name, device_infos); } arv_gv_interface_device_infos_ref (device_infos); g_hash_table_replace (gv_interface->priv->devices, device_infos->mac_string, device_infos); arv_gv_interface_device_infos_unref (device_infos); } } } while (count > 0); } } while (1); }
gboolean arv_gv_fake_camera_start (ArvGvFakeCamera *gv_fake_camera) { struct ifaddrs *ifap = NULL; struct ifaddrs *ifap_iter; int return_value; gboolean interface_found = FALSE; gboolean binding_error = FALSE; g_return_val_if_fail (ARV_IS_GV_FAKE_CAMERA (gv_fake_camera), FALSE); return_value = getifaddrs (&ifap); if (return_value < 0) { arv_warning_device ("[GvFakeCamera::start] No network interface found"); return FALSE; } for (ifap_iter = ifap ;ifap_iter != NULL && !interface_found; ifap_iter = ifap_iter->ifa_next) { if ((ifap_iter->ifa_flags & IFF_UP) != 0 && (ifap_iter->ifa_flags & IFF_POINTOPOINT) == 0 && (ifap_iter->ifa_addr->sa_family == AF_INET) && g_strcmp0 (ifap_iter->ifa_name, gv_fake_camera->priv->interface_name) == 0) { GSocketAddress *socket_address; GSocketAddress *inet_socket_address; GInetAddress *inet_address; char *gvcp_address_string; char *discovery_address_string; socket_address = g_socket_address_new_from_native (ifap_iter->ifa_addr, sizeof (struct sockaddr)); inet_address = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (socket_address)); gvcp_address_string = g_inet_address_to_string (inet_address); arv_debug_device ("[GvFakeCamera::start] Interface address = %s", gvcp_address_string); inet_socket_address = g_inet_socket_address_new (inet_address, ARV_GVCP_PORT); gv_fake_camera->priv->gvcp_socket = g_socket_new (G_SOCKET_FAMILY_IPV4, G_SOCKET_TYPE_DATAGRAM, G_SOCKET_PROTOCOL_UDP, NULL); if (!g_socket_bind (gv_fake_camera->priv->gvcp_socket, inet_socket_address, FALSE, NULL)) binding_error = TRUE; g_socket_set_blocking (gv_fake_camera->priv->gvcp_socket, FALSE); arv_fake_camera_set_inet_address (gv_fake_camera->priv->camera, inet_address); g_object_unref (inet_socket_address); inet_socket_address = g_inet_socket_address_new (inet_address, 0); gv_fake_camera->priv->gvsp_socket = g_socket_new (G_SOCKET_FAMILY_IPV4, G_SOCKET_TYPE_DATAGRAM, G_SOCKET_PROTOCOL_UDP, NULL); if (!g_socket_bind (gv_fake_camera->priv->gvsp_socket, inet_socket_address, FALSE, NULL)) binding_error = TRUE; g_clear_object (&inet_socket_address); g_clear_object (&socket_address); inet_address = g_inet_address_new_from_string ("255.255.255.255"); discovery_address_string = g_inet_address_to_string (inet_address); arv_debug_device ("[GvFakeCamera::start] Discovery address = %s", discovery_address_string); inet_socket_address = g_inet_socket_address_new (inet_address, ARV_GVCP_PORT); if (g_strcmp0 (gvcp_address_string, discovery_address_string) == 0) gv_fake_camera->priv->discovery_socket = NULL; else { gv_fake_camera->priv->discovery_socket = g_socket_new (G_SOCKET_FAMILY_IPV4, G_SOCKET_TYPE_DATAGRAM, G_SOCKET_PROTOCOL_UDP, NULL); if (!g_socket_bind (gv_fake_camera->priv->discovery_socket, inet_socket_address, FALSE, NULL)) binding_error = TRUE; g_socket_set_blocking (gv_fake_camera->priv->discovery_socket, FALSE); } g_clear_object (&inet_socket_address); g_clear_object (&inet_address); g_free (gvcp_address_string); g_free (discovery_address_string); gv_fake_camera->priv->gvcp_fds[0].fd = g_socket_get_fd (gv_fake_camera->priv->gvcp_socket); gv_fake_camera->priv->gvcp_fds[0].events = G_IO_IN; gv_fake_camera->priv->gvcp_fds[0].revents = 0; if (gv_fake_camera->priv->discovery_socket != NULL) { gv_fake_camera->priv->gvcp_fds[1].fd = g_socket_get_fd (gv_fake_camera->priv->discovery_socket); gv_fake_camera->priv->gvcp_fds[1].events = G_IO_IN; gv_fake_camera->priv->gvcp_fds[1].revents = 0; gv_fake_camera->priv->n_gvcp_fds = 2; } else gv_fake_camera->priv->n_gvcp_fds = 1; interface_found = TRUE; } } freeifaddrs (ifap); if (binding_error) { g_clear_object (&gv_fake_camera->priv->gvcp_socket); g_clear_object (&gv_fake_camera->priv->gvsp_socket); g_clear_object (&gv_fake_camera->priv->discovery_socket); return FALSE; } if (!interface_found) { return FALSE; } gv_fake_camera->priv->cancel = FALSE; gv_fake_camera->priv->thread = g_thread_new ("arv_fake_gv_fake_camera", _thread, gv_fake_camera); return TRUE; }
static ArvGvDiscoverSocketList * arv_gv_discover_socket_list_new (void) { ArvGvDiscoverSocketList *socket_list; GInetAddress *broadcast_address; GSList *iter; const char *envar; struct ifaddrs *ifap = NULL; struct ifaddrs *ifap_iter; int i; socket_list = g_new0 (ArvGvDiscoverSocketList, 1); if (getifaddrs (&ifap) < 0) return socket_list; broadcast_address = g_inet_address_new_from_string ("255.255.255.255"); for (ifap_iter = ifap; ifap_iter != NULL; ifap_iter = ifap_iter->ifa_next) { if ((ifap_iter->ifa_flags & IFF_UP) != 0 && (ifap_iter->ifa_flags & IFF_POINTOPOINT) == 0 && (ifap_iter->ifa_addr != NULL) && (ifap_iter->ifa_addr->sa_family == AF_INET)) { ArvGvDiscoverSocket *discover_socket = g_new0 (ArvGvDiscoverSocket, 1); GSocketAddress *socket_address; GInetAddress *inet_address; char *inet_address_string; GError *error = NULL; socket_address = g_socket_address_new_from_native (ifap_iter->ifa_addr, sizeof (struct sockaddr)); inet_address = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (socket_address)); inet_address_string = g_inet_address_to_string (inet_address); arv_debug_interface ("[GvDiscoverSocket::new] Add interface %s", inet_address_string); g_free (inet_address_string); discover_socket->interface_address = g_inet_socket_address_new (inet_address, 0); g_object_unref (socket_address); discover_socket->target_address = g_inet_socket_address_new (broadcast_address, ARV_GVCP_PORT); discover_socket->socket = g_socket_new (G_SOCKET_FAMILY_IPV4, G_SOCKET_TYPE_DATAGRAM, G_SOCKET_PROTOCOL_UDP, NULL); g_socket_bind (discover_socket->socket, discover_socket->interface_address, TRUE, &error); socket_list->sockets = g_slist_prepend (socket_list->sockets, discover_socket); socket_list->n_sockets++; } } g_object_unref (broadcast_address); freeifaddrs (ifap); if ((envar=g_getenv("ARV_IPS"))!=NULL) { gchar **ips_alloc, **ips, *addr; ips_alloc = ips = g_strsplit(envar, ":", -1); for (addr = *ips; addr; addr = *++ips) { ArvGvDiscoverSocket *discover_socket; GSocketAddress *target_addr = g_inet_socket_address_new_from_string(addr, ARV_GVCP_PORT); if(!target_addr) continue; discover_socket = g_new0 (ArvGvDiscoverSocket, 1); discover_socket->target_address = target_addr; discover_socket->interface_address = g_inet_socket_address_new_from_string("0.0.0.0", ARV_GVCP_PORT); /* TODO, wrong */ discover_socket->socket = g_socket_new (G_SOCKET_FAMILY_IPV4, G_SOCKET_TYPE_DATAGRAM, G_SOCKET_PROTOCOL_UDP, NULL); /* implict bind of wildcard w/ arbitrary port */ arv_debug_interface("[GvDiscoverSocket::new] Add unicast destination %s", addr); socket_list->sockets = g_slist_prepend (socket_list->sockets, discover_socket); socket_list->n_sockets++; } g_strfreev(ips_alloc); } socket_list->poll_fds = g_new (GPollFD, socket_list->n_sockets); for (i = 0, iter = socket_list->sockets; iter != NULL; i++, iter = iter->next) { ArvGvDiscoverSocket *discover_socket = iter->data; socket_list->poll_fds[i].fd = g_socket_get_fd (discover_socket->socket); socket_list->poll_fds[i].events = G_IO_IN; socket_list->poll_fds[i].revents = 0; } return socket_list; }
static GSocketAddress * g_proxy_address_enumerator_next (GSocketAddressEnumerator *enumerator, GCancellable *cancellable, GError **error) { GProxyAddressEnumeratorPrivate *priv = GET_PRIVATE (enumerator); GSocketAddress *result = NULL; GError *first_error = NULL; if (priv->proxies == NULL) { GProxyResolver *resolver = g_proxy_resolver_get_default (); priv->proxies = g_proxy_resolver_lookup (resolver, priv->dest_uri, cancellable, error); priv->next_proxy = priv->proxies; if (priv->proxies == NULL) return NULL; } while (result == NULL && (*priv->next_proxy || priv->addr_enum)) { gchar *dest_hostname; gchar *dest_protocol; GInetSocketAddress *inetsaddr; GInetAddress *inetaddr; guint16 port; next_enumerator (priv); if (!priv->addr_enum) continue; if (priv->proxy_address == NULL) { priv->proxy_address = g_socket_address_enumerator_next ( priv->addr_enum, cancellable, first_error ? NULL : &first_error); } if (priv->proxy_address == NULL) { g_object_unref (priv->addr_enum); priv->addr_enum = NULL; if (priv->dest_ips) { g_resolver_free_addresses (priv->dest_ips); priv->dest_ips = NULL; } continue; } if (strcmp ("direct", priv->proxy_type) == 0) { result = priv->proxy_address; priv->proxy_address = NULL; continue; } if (!priv->supports_hostname) { GInetAddress *dest_ip; if (!priv->dest_ips) { GResolver *resolver; resolver = g_resolver_get_default(); priv->dest_ips = g_resolver_lookup_by_name (resolver, priv->dest_hostname, cancellable, first_error ? NULL : &first_error); g_object_unref (resolver); if (!priv->dest_ips) { g_object_unref (priv->proxy_address); priv->proxy_address = NULL; continue; } } if (!priv->next_dest_ip) priv->next_dest_ip = priv->dest_ips; dest_ip = G_INET_ADDRESS (priv->next_dest_ip->data); dest_hostname = g_inet_address_to_string (dest_ip); priv->next_dest_ip = g_list_next (priv->next_dest_ip); } else { dest_hostname = g_strdup (priv->dest_hostname); } dest_protocol = g_uri_parse_scheme (priv->dest_uri); g_return_val_if_fail (G_IS_INET_SOCKET_ADDRESS (priv->proxy_address), NULL); inetsaddr = G_INET_SOCKET_ADDRESS (priv->proxy_address); inetaddr = g_inet_socket_address_get_address (inetsaddr); port = g_inet_socket_address_get_port (inetsaddr); result = g_object_new (G_TYPE_PROXY_ADDRESS, "address", inetaddr, "port", port, "protocol", priv->proxy_type, "destination-protocol", dest_protocol, "destination-hostname", dest_hostname, "destination-port", priv->dest_port, "username", priv->proxy_username, "password", priv->proxy_password, "uri", priv->proxy_uri, NULL); g_free (dest_hostname); g_free (dest_protocol); if (priv->supports_hostname || priv->next_dest_ip == NULL) { g_object_unref (priv->proxy_address); priv->proxy_address = NULL; } } if (result == NULL && first_error) g_propagate_error (error, first_error); else if (first_error) g_error_free (first_error); return result; }
ArvFakeGvCamera * arv_fake_gv_camera_new (const char *interface_name) { ArvFakeGvCamera *gv_camera; struct ifaddrs *ifap = NULL; struct ifaddrs *ifap_iter; int return_value; gboolean interface_found = FALSE; gboolean binding_error = FALSE; g_return_val_if_fail (interface_name != NULL, NULL); gv_camera = g_new0 (ArvFakeGvCamera, 1); gv_camera->camera = arv_fake_camera_new ("GV01"); return_value = getifaddrs (&ifap); if (return_value < 0) { g_warning ("[FakeGvCamera::new] No network interface found"); return NULL; } for (ifap_iter = ifap ;ifap_iter != NULL && !interface_found; ifap_iter = ifap_iter->ifa_next) { if ((ifap_iter->ifa_flags & IFF_UP) != 0 && (ifap_iter->ifa_flags & IFF_POINTOPOINT) == 0 && (ifap_iter->ifa_addr->sa_family == AF_INET) && g_strcmp0 (ifap_iter->ifa_name, interface_name) == 0) { GSocketAddress *socket_address; GSocketAddress *inet_socket_address; GInetAddress *inet_address; char *gvcp_address_string; char *discovery_address_string; socket_address = g_socket_address_new_from_native (ifap_iter->ifa_addr, sizeof (struct sockaddr)); inet_address = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (socket_address)); gvcp_address_string = g_inet_address_to_string (inet_address); arv_debug_device ("[FakeGvCamera::new] Interface address = %s", gvcp_address_string); inet_socket_address = g_inet_socket_address_new (inet_address, ARV_GVCP_PORT); gv_camera->gvcp_socket = g_socket_new (G_SOCKET_FAMILY_IPV4, G_SOCKET_TYPE_DATAGRAM, G_SOCKET_PROTOCOL_UDP, NULL); if (!g_socket_bind (gv_camera->gvcp_socket, inet_socket_address, FALSE, NULL)) binding_error = TRUE; g_socket_set_blocking (gv_camera->gvcp_socket, FALSE); arv_fake_camera_set_inet_address (gv_camera->camera, inet_address); g_object_unref (inet_socket_address); inet_socket_address = g_inet_socket_address_new (inet_address, 0); gv_camera->gvsp_socket = g_socket_new (G_SOCKET_FAMILY_IPV4, G_SOCKET_TYPE_DATAGRAM, G_SOCKET_PROTOCOL_UDP, NULL); if (!g_socket_bind (gv_camera->gvsp_socket, inet_socket_address, FALSE, NULL)) binding_error = TRUE; g_object_unref (inet_socket_address); g_object_unref (socket_address); socket_address = g_socket_address_new_from_native (ifap_iter->ifa_broadaddr, sizeof (struct sockaddr)); inet_address = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (socket_address)); discovery_address_string = g_inet_address_to_string (inet_address); arv_debug_device ("[FakeGvCamera::new] Discovery address = %s", discovery_address_string); inet_socket_address = g_inet_socket_address_new (inet_address, ARV_GVCP_PORT); if (g_strcmp0 (gvcp_address_string, discovery_address_string) == 0) gv_camera->discovery_socket = NULL; else { gv_camera->discovery_socket = g_socket_new (G_SOCKET_FAMILY_IPV4, G_SOCKET_TYPE_DATAGRAM, G_SOCKET_PROTOCOL_UDP, NULL); if (!g_socket_bind (gv_camera->discovery_socket, inet_socket_address, FALSE, NULL)) binding_error = TRUE; g_socket_set_blocking (gv_camera->discovery_socket, FALSE); } g_object_unref (inet_socket_address); g_object_unref (socket_address); g_free (gvcp_address_string); g_free (discovery_address_string); gv_camera->gvcp_fds[0].fd = g_socket_get_fd (gv_camera->gvcp_socket); gv_camera->gvcp_fds[0].events = G_IO_IN; gv_camera->gvcp_fds[0].revents = 0; if (gv_camera->discovery_socket != NULL) { gv_camera->gvcp_fds[1].fd = g_socket_get_fd (gv_camera->discovery_socket); gv_camera->gvcp_fds[1].events = G_IO_IN; gv_camera->gvcp_fds[1].revents = 0; gv_camera->n_gvcp_fds = 2; } else gv_camera->n_gvcp_fds = 1; interface_found = TRUE; } } freeifaddrs (ifap); if (binding_error) goto BINDING_ERROR; if (!interface_found) goto INTERFACE_ERROR; gv_camera->cancel = FALSE; gv_camera->gvsp_thread = arv_g_thread_new ("arv_fake_gv_camera", arv_fake_gv_camera_thread, gv_camera); return gv_camera; BINDING_ERROR: g_object_unref (gv_camera->gvcp_socket); if (gv_camera->discovery_socket != NULL) g_object_unref (gv_camera->discovery_socket); g_object_unref (gv_camera->gvsp_socket); INTERFACE_ERROR: g_object_unref (gv_camera->camera); g_free (gv_camera); return NULL; }
ArvDevice * arv_gv_device_new (GInetAddress *interface_address, GInetAddress *device_address) { ArvGvDevice *gv_device; ArvGvDeviceIOData *io_data; ArvGvDeviceHeartbeatData *heartbeat_data; ArvGcRegisterDescriptionNode *register_description; ArvDomDocument *document; char *address_string; guint32 capabilities; g_return_val_if_fail (G_IS_INET_ADDRESS (interface_address), NULL); g_return_val_if_fail (G_IS_INET_ADDRESS (device_address), NULL); address_string = g_inet_address_to_string (interface_address); arv_debug_device ("[GvDevice::new] Interface address = %s", address_string); g_free (address_string); address_string = g_inet_address_to_string (device_address); arv_debug_device ("[GvDevice::new] Device address = %s", address_string); g_free (address_string); gv_device = g_object_new (ARV_TYPE_GV_DEVICE, NULL); io_data = g_new0 (ArvGvDeviceIOData, 1); #if GLIB_CHECK_VERSION(2,32,0) g_mutex_init (&io_data->mutex); #else io_data->mutex = g_mutex_new (); #endif io_data->packet_id = 65300; /* Start near the end of the circular counter */ io_data->interface_address = g_inet_socket_address_new (interface_address, 0); io_data->device_address = g_inet_socket_address_new (device_address, ARV_GVCP_PORT); io_data->socket = g_socket_new (G_SOCKET_FAMILY_IPV4, G_SOCKET_TYPE_DATAGRAM, G_SOCKET_PROTOCOL_UDP, NULL); g_socket_bind (io_data->socket, io_data->interface_address, TRUE, NULL); io_data->buffer = g_malloc (ARV_GV_DEVICE_BUFFER_SIZE); io_data->gvcp_n_retries = ARV_GV_DEVICE_GVCP_N_RETRIES_DEFAULT; io_data->gvcp_timeout_ms = ARV_GV_DEVICE_GVCP_TIMEOUT_MS_DEFAULT; io_data->poll_in_event.fd = g_socket_get_fd (io_data->socket); io_data->poll_in_event.events = G_IO_IN; io_data->poll_in_event.revents = 0; gv_device->priv->io_data = io_data; arv_gv_device_load_genicam (gv_device); arv_gv_device_take_control (gv_device); heartbeat_data = g_new (ArvGvDeviceHeartbeatData, 1); heartbeat_data->gv_device = gv_device; heartbeat_data->io_data = io_data; heartbeat_data->period_us = ARV_GV_DEVICE_HEARTBEAT_PERIOD_US; heartbeat_data->cancel = FALSE; gv_device->priv->heartbeat_data = heartbeat_data; gv_device->priv->heartbeat_thread = arv_g_thread_new ("arv_gv_heartbeat", arv_gv_device_heartbeat_thread, gv_device->priv->heartbeat_data); arv_device_read_register (ARV_DEVICE (gv_device), ARV_GVBS_GVCP_CAPABILITY_OFFSET, &capabilities, NULL); gv_device->priv->is_packet_resend_supported = (capabilities & ARV_GVBS_GVCP_CAPABILITY_PACKET_RESEND) != 0; gv_device->priv->is_write_memory_supported = (capabilities & ARV_GVBS_GVCP_CAPABILITY_WRITE_MEMORY) != 0; arv_debug_device ("[GvDevice::new] Packet resend = %s", gv_device->priv->is_packet_resend_supported ? "yes" : "no"); arv_debug_device ("[GvDevice::new] Write memory = %s", gv_device->priv->is_write_memory_supported ? "yes" : "no"); document = ARV_DOM_DOCUMENT (gv_device->priv->genicam); register_description = ARV_GC_REGISTER_DESCRIPTION_NODE (arv_dom_document_get_document_element (document)); if (!arv_gc_register_description_node_check_schema_version (register_description, 1, 1, 0)) arv_debug_device ("[GvDevice::new] Register workaround = yes"); return ARV_DEVICE (gv_device); }