static void arv_gv_discover_socket_list_send_discover_packet (ArvGvDiscoverSocketList *socket_list) { ArvGvcpPacket *packet; GSList *iter; size_t size; packet = arv_gvcp_packet_new_discovery_cmd (&size); for (iter = socket_list->sockets; iter != NULL; iter = iter->next) { ArvGvDiscoverSocket *discover_socket = iter->data; GError *error = NULL; arv_gv_discover_socket_set_broadcast (discover_socket, TRUE); g_socket_send_to (discover_socket->socket, discover_socket->target_address, (const char *) packet, size, NULL, &error); if (error != NULL) { arv_warning_interface ("[ArvGVInterface::send_discover_packet] Error: %s", error->message); g_error_free (error); } arv_gv_discover_socket_set_broadcast (discover_socket, FALSE); } arv_gvcp_packet_free (packet); }
static void arv_gv_interface_send_discover_packet (ArvGvInterface *gv_interface) { ArvGvcpPacket *packet; GSList *iter; size_t size; arv_gv_interface_build_discover_infos_list (gv_interface); packet = arv_gvcp_packet_new_discovery_cmd (&size); for (iter = gv_interface->priv->discover_infos_list; iter != NULL; iter = iter->next) { ArvGvInterfaceDiscoverInfos *infos = iter->data; GError *error = NULL; arv_gv_interface_socket_set_broadcast (infos->socket, TRUE); g_socket_send_to (infos->socket, infos->broadcast_address, (const char *) packet, size, NULL, &error); if (error != NULL) g_message ("error: %s", error->message); arv_gv_interface_socket_set_broadcast (infos->socket, FALSE); } arv_gvcp_packet_free (packet); }
static void arv_gv_discover_socket_list_send_discover_packet (ArvGvDiscoverSocketList *socket_list) { GInetAddress *broadcast_address; GSocketAddress *broadcast_socket_address; ArvGvcpPacket *packet; GSList *iter; size_t size; packet = arv_gvcp_packet_new_discovery_cmd (&size); broadcast_address = g_inet_address_new_from_string ("255.255.255.255"); broadcast_socket_address = g_inet_socket_address_new (broadcast_address, ARV_GVCP_PORT); g_object_unref (broadcast_address); for (iter = socket_list->sockets; iter != NULL; iter = iter->next) { ArvGvDiscoverSocket *discover_socket = iter->data; GError *error = NULL; arv_gv_discover_socket_set_broadcast (discover_socket, TRUE); g_socket_send_to (discover_socket->socket, broadcast_socket_address, (const char *) packet, size, NULL, &error); if (error != NULL) { arv_warning_interface ("[ArvGVInterface::send_discover_packet] Error: %s", error->message); g_error_free (error); } arv_gv_discover_socket_set_broadcast (discover_socket, FALSE); } g_object_unref (broadcast_socket_address); arv_gvcp_packet_free (packet); }
/** * gst_net_time_packet_send: * @packet: the #GstNetTimePacket to send * @socket: socket to send the time packet on * @dest_address: address to send the time packet to * @error: return address for a #GError, or NULL * * Sends a #GstNetTimePacket over a socket. * * MT safe. * * Returns: TRUE if successful, FALSE in case an error occurred. */ gboolean gst_net_time_packet_send (const GstNetTimePacket * packet, GSocket * socket, GSocketAddress * dest_address, GError ** error) { gboolean was_blocking; guint8 *buffer; gssize res; g_return_val_if_fail (packet != NULL, FALSE); g_return_val_if_fail (G_IS_SOCKET (socket), FALSE); g_return_val_if_fail (G_IS_SOCKET_ADDRESS (dest_address), FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); was_blocking = g_socket_get_blocking (socket); if (was_blocking) g_socket_set_blocking (socket, FALSE); /* FIXME: avoid pointless alloc/free, serialise into stack-allocated buffer */ buffer = gst_net_time_packet_serialize (packet); res = g_socket_send_to (socket, dest_address, (const gchar *) buffer, GST_NET_TIME_PACKET_SIZE, NULL, error); /* datagram packets should be sent as a whole or not at all */ g_assert (res < 0 || res == GST_NET_TIME_PACKET_SIZE); g_free (buffer); if (was_blocking) g_socket_set_blocking (socket, TRUE); return (res == GST_NET_TIME_PACKET_SIZE); }
static gboolean resendRequest(gpointer data) { ResendMark *mark = (ResendMark *)data; AirplayRendererPrivate *priv = AIRPLAY_RENDERER_GET_PRIVATE(mark->self); guint nRemove = g_hash_table_foreach_remove(priv->resendTable, removeOutdated, &priv->seq); g_print("Resend Table Removed: %d\n", nRemove); GList *keys = g_hash_table_get_keys(priv->resendTable); guint length = g_list_length(keys); if(length <= 2) { goto free; } int i = 1; for(; i<length-1; ++i) { gint before = *(gint *)g_list_nth_data(keys, i-1); gint idx = *(gint *)g_list_nth_data(keys, i); if(idx != before + 1) { gint seqNumStart = before + 1; gint seqNumEnd = idx - 1; gchar request[8]; request[0] = 0x80; request[1] = 0x55 | 0x80; *(gushort *)(request + 2) = htons(1); *(gushort *)(request + 4) = htons(seqNumStart); *(gushort *)(request + 6) = htons(seqNumEnd - seqNumStart + 1); GError *error = NULL; g_socket_send_to(priv->controlSocket, g_inet_socket_address_new(g_inet_socket_address_get_address((GInetSocketAddress *)mark->clientAddr), priv->controlPortClient), request, sizeof(request), NULL, &error); if(error) { g_printerr("AirplayRenderer: resendRequest failed: %s\n", error->message); } g_print("Resend Quest : %d %d\n", seqNumStart, seqNumEnd); } } free: g_list_free(keys); g_free(mark); g_source_remove(priv->resendTimer); priv->resendTimer = 0; return FALSE; }
static GstFlowReturn gst_rtsp_sink_render(GstBaseSink * bsink, GstBuffer * buffer) { GstMapInfo map; GstRTSPsink *sink = (GstRTSPsink*)bsink; // Let us access the data gst_buffer_map(buffer, &map, GST_MAP_READ); // send data over udp, period. if (g_socket_send_to(sink->socket, sink->sa, map.data, map.size, NULL, NULL) == -1 ) g_print("Not godd sending failed !"); if (sink->debug) g_print("Data len %d\n", map.size); gst_buffer_unmap(buffer, &map); return GST_FLOW_OK; }
static void _send_packet_request (ArvGvStreamThreadData *thread_data, guint32 frame_id, guint32 first_block, guint32 last_block) { ArvGvcpPacket *packet; size_t packet_size; thread_data->packet_id = arv_gvcp_next_packet_id (thread_data->packet_id); packet = arv_gvcp_packet_new_packet_resend_cmd (frame_id, first_block, last_block, thread_data->packet_id, &packet_size); arv_log_stream_thread ("[GvStream::send_packet_request] frame_id = %u (%d - %d)", frame_id, first_block, last_block); arv_gvcp_packet_debug (packet, ARV_DEBUG_LEVEL_LOG); g_socket_send_to (thread_data->socket, thread_data->device_address, (const char *) packet, packet_size, NULL, NULL); arv_gvcp_packet_free (packet); }
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; }
void handle_control_packet (ArvFakeGvCamera *gv_camera, GSocket *socket, GSocketAddress *remote_address, ArvGvcpPacket *packet, size_t size) { ArvGvcpPacket *ack_packet = NULL; size_t ack_packet_size; guint32 block_address; guint32 block_size; guint16 packet_id; guint32 register_address; guint32 register_value; gboolean write_access; if (gv_camera->controller_address != NULL) { struct timespec time; guint64 elapsed_ms; clock_gettime (CLOCK_MONOTONIC, &time); elapsed_ms = 1000 * (time.tv_sec - gv_camera->controller_time.tv_sec) + (time.tv_nsec - gv_camera->controller_time.tv_nsec) / 1000000; if (elapsed_ms > arv_fake_camera_get_heartbeat_timeout (gv_camera->camera)) { g_object_ref (gv_camera->controller_address); gv_camera->controller_address = NULL; write_access = TRUE; arv_warning_device ("[FakeGvCamera::handle_control_packet] Heartbeat timeout"); arv_fake_camera_set_control_channel_privilege (gv_camera->camera, 0); } else write_access = _g_inet_socket_address_is_equal (G_INET_SOCKET_ADDRESS (remote_address), G_INET_SOCKET_ADDRESS (gv_camera->controller_address)); } else write_access = TRUE; arv_gvcp_packet_debug (packet, ARV_DEBUG_LEVEL_LOG); packet_id = arv_gvcp_packet_get_packet_id (packet); switch (g_ntohs (packet->header.command)) { case ARV_GVCP_COMMAND_DISCOVERY_CMD: ack_packet = arv_gvcp_packet_new_discovery_ack (&ack_packet_size); arv_debug_device ("[FakeGvCamera::handle_control_packet] Discovery command"); arv_fake_camera_read_memory (gv_camera->camera, 0, ARV_GVBS_DISCOVERY_DATA_SIZE, &ack_packet->data); break; case ARV_GVCP_COMMAND_READ_MEMORY_CMD: arv_gvcp_packet_get_read_memory_cmd_infos (packet, &block_address, &block_size); arv_debug_device ("[FakeGvCamera::handle_control_packet] Read memory command %d (%d)", block_address, block_size); ack_packet = arv_gvcp_packet_new_read_memory_ack (block_address, block_size, packet_id, &ack_packet_size); arv_fake_camera_read_memory (gv_camera->camera, block_address, block_size, arv_gvcp_packet_get_read_memory_ack_data (ack_packet)); break; case ARV_GVCP_COMMAND_WRITE_MEMORY_CMD: if (!write_access) break; arv_gvcp_packet_get_write_memory_cmd_infos (packet, &block_address, &block_size); arv_debug_device ("[FakeGvCamera::handle_control_packet] Write memory command %d (%d)", block_address, block_size); arv_fake_camera_write_memory (gv_camera->camera, block_address, block_size, arv_gvcp_packet_get_write_memory_cmd_data (packet)); ack_packet = arv_gvcp_packet_new_write_memory_ack (block_address, packet_id, &ack_packet_size); break; case ARV_GVCP_COMMAND_READ_REGISTER_CMD: arv_gvcp_packet_get_read_register_cmd_infos (packet, ®ister_address); arv_fake_camera_read_register (gv_camera->camera, register_address, ®ister_value); arv_debug_device ("[FakeGvCamera::handle_control_packet] Read register command %d -> %d", register_address, register_value); ack_packet = arv_gvcp_packet_new_read_register_ack (register_value, packet_id, &ack_packet_size); if (register_address == ARV_GVBS_CONTROL_CHANNEL_PRIVILEGE_OFFSET) clock_gettime (CLOCK_MONOTONIC, &gv_camera->controller_time); break; case ARV_GVCP_COMMAND_WRITE_REGISTER_CMD: if (!write_access) break; arv_gvcp_packet_get_write_register_cmd_infos (packet, ®ister_address, ®ister_value); arv_fake_camera_write_register (gv_camera->camera, register_address, register_value); arv_debug_device ("[FakeGvCamera::handle_control_packet] Write register command %d -> %d", register_address, register_value); ack_packet = arv_gvcp_packet_new_write_register_ack (register_value, packet_id, &ack_packet_size); break; default: arv_warning_device ("[FakeGvCamera::handle_control_packet] Unknown command"); } if (ack_packet != NULL) { g_socket_send_to (socket, remote_address, (char *) ack_packet, ack_packet_size, NULL, NULL); arv_gvcp_packet_debug (ack_packet, ARV_DEBUG_LEVEL_LOG); g_free (ack_packet); } if (gv_camera->controller_address == NULL && arv_fake_camera_get_control_channel_privilege (gv_camera->camera) != 0) { g_object_ref (remote_address); gv_camera->controller_address = remote_address; clock_gettime (CLOCK_MONOTONIC, &gv_camera->controller_time); } }
gboolean handle_control_packet (ArvGvFakeCamera *gv_fake_camera, GSocket *socket, GSocketAddress *remote_address, ArvGvcpPacket *packet, size_t size) { ArvGvcpPacket *ack_packet = NULL; size_t ack_packet_size; guint32 block_address; guint32 block_size; guint16 packet_id; guint16 packet_type; guint32 register_address; guint32 register_value; gboolean write_access; gboolean success = FALSE; if (gv_fake_camera->priv->controller_address != NULL) { gint64 time; guint64 elapsed_ms; time = g_get_real_time (); elapsed_ms = (time - gv_fake_camera->priv->controller_time) / 1000; if (elapsed_ms > arv_fake_camera_get_heartbeat_timeout (gv_fake_camera->priv->camera)) { g_object_unref (gv_fake_camera->priv->controller_address); gv_fake_camera->priv->controller_address = NULL; write_access = TRUE; arv_warning_device ("[GvFakeCamera::handle_control_packet] Heartbeat timeout"); arv_fake_camera_set_control_channel_privilege (gv_fake_camera->priv->camera, 0); } else write_access = _g_inet_socket_address_is_equal (G_INET_SOCKET_ADDRESS (remote_address), G_INET_SOCKET_ADDRESS (gv_fake_camera->priv->controller_address)); } else write_access = TRUE; arv_gvcp_packet_debug (packet, ARV_DEBUG_LEVEL_LOG); packet_id = arv_gvcp_packet_get_packet_id (packet); packet_type = arv_gvcp_packet_get_packet_type (packet); if (packet_type != ARV_GVCP_PACKET_TYPE_CMD) { arv_warning_device ("[GvFakeCamera::handle_control_packet] Unknown packet type"); return FALSE; } switch (g_ntohs (packet->header.command)) { case ARV_GVCP_COMMAND_DISCOVERY_CMD: ack_packet = arv_gvcp_packet_new_discovery_ack (&ack_packet_size); arv_debug_device ("[GvFakeCamera::handle_control_packet] Discovery command"); arv_fake_camera_read_memory (gv_fake_camera->priv->camera, 0, ARV_GVBS_DISCOVERY_DATA_SIZE, &ack_packet->data); break; case ARV_GVCP_COMMAND_READ_MEMORY_CMD: arv_gvcp_packet_get_read_memory_cmd_infos (packet, &block_address, &block_size); arv_debug_device ("[GvFakeCamera::handle_control_packet] Read memory command %d (%d)", block_address, block_size); ack_packet = arv_gvcp_packet_new_read_memory_ack (block_address, block_size, packet_id, &ack_packet_size); arv_fake_camera_read_memory (gv_fake_camera->priv->camera, block_address, block_size, arv_gvcp_packet_get_read_memory_ack_data (ack_packet)); break; case ARV_GVCP_COMMAND_WRITE_MEMORY_CMD: arv_gvcp_packet_get_write_memory_cmd_infos (packet, &block_address, &block_size); if (!write_access) { arv_warning_device("[GvFakeCamera::handle_control_packet] Ignore Write memory command %d (%d) not controller", block_address, block_size); break; } arv_debug_device ("[GvFakeCamera::handle_control_packet] Write memory command %d (%d)", block_address, block_size); arv_fake_camera_write_memory (gv_fake_camera->priv->camera, block_address, block_size, arv_gvcp_packet_get_write_memory_cmd_data (packet)); ack_packet = arv_gvcp_packet_new_write_memory_ack (block_address, packet_id, &ack_packet_size); break; case ARV_GVCP_COMMAND_READ_REGISTER_CMD: arv_gvcp_packet_get_read_register_cmd_infos (packet, ®ister_address); arv_fake_camera_read_register (gv_fake_camera->priv->camera, register_address, ®ister_value); arv_debug_device ("[GvFakeCamera::handle_control_packet] Read register command %d -> %d", register_address, register_value); ack_packet = arv_gvcp_packet_new_read_register_ack (register_value, packet_id, &ack_packet_size); if (register_address == ARV_GVBS_CONTROL_CHANNEL_PRIVILEGE_OFFSET) gv_fake_camera->priv->controller_time = g_get_real_time (); break; case ARV_GVCP_COMMAND_WRITE_REGISTER_CMD: arv_gvcp_packet_get_write_register_cmd_infos (packet, ®ister_address, ®ister_value); if (!write_access) { arv_warning_device("[GvFakeCamera::handle_control_packet] Ignore Write register command %d (%d) not controller", register_address, register_value); break; } arv_fake_camera_write_register (gv_fake_camera->priv->camera, register_address, register_value); arv_debug_device ("[GvFakeCamera::handle_control_packet] Write register command %d -> %d", register_address, register_value); ack_packet = arv_gvcp_packet_new_write_register_ack (1, packet_id, &ack_packet_size); break; default: arv_warning_device ("[GvFakeCamera::handle_control_packet] Unknown command"); } if (ack_packet != NULL) { g_socket_send_to (socket, remote_address, (char *) ack_packet, ack_packet_size, NULL, NULL); arv_gvcp_packet_debug (ack_packet, ARV_DEBUG_LEVEL_LOG); g_free (ack_packet); success = TRUE; } if (gv_fake_camera->priv->controller_address == NULL && arv_fake_camera_get_control_channel_privilege (gv_fake_camera->priv->camera) != 0) { g_object_ref (remote_address); arv_debug_device("[GvFakeCamera::handle_control_packet] New controller"); gv_fake_camera->priv->controller_address = remote_address; gv_fake_camera->priv->controller_time = g_get_real_time (); } else if (gv_fake_camera->priv->controller_address != NULL && arv_fake_camera_get_control_channel_privilege (gv_fake_camera->priv->camera) == 0) { g_object_unref (gv_fake_camera->priv->controller_address); arv_debug_device("[GvFakeCamera::handle_control_packet] Controller releases"); gv_fake_camera->priv->controller_address = NULL; gv_fake_camera->priv->controller_time = g_get_real_time (); } return success; }
int main (int argc, char *argv[]) { GSocket *socket, *new_socket, *recv_socket; GSocketAddress *src_address; GSocketAddress *address; GSocketType socket_type; GError *error = NULL; GOptionContext *context; GCancellable *cancellable; g_thread_init (NULL); g_type_init (); context = g_option_context_new (" - Test GSocket server stuff"); g_option_context_add_main_entries (context, cmd_entries, NULL); if (!g_option_context_parse (context, &argc, &argv, &error)) { g_printerr ("%s: %s\n", argv[0], error->message); return 1; } if (cancel_timeout) { cancellable = g_cancellable_new (); g_thread_create (cancel_thread, cancellable, FALSE, NULL); } else { cancellable = NULL; } loop = g_main_loop_new (NULL, FALSE); if (use_udp) socket_type = G_SOCKET_TYPE_DATAGRAM; else socket_type = G_SOCKET_TYPE_STREAM; socket = g_socket_new (G_SOCKET_FAMILY_IPV4, socket_type, 0, &error); if (socket == NULL) { g_printerr ("%s: %s\n", argv[0], error->message); return 1; } if (non_blocking) g_socket_set_blocking (socket, FALSE); src_address = g_inet_socket_address_new (g_inet_address_new_any (G_SOCKET_FAMILY_IPV4), port); if (!g_socket_bind (socket, src_address, !dont_reuse_address, &error)) { g_printerr ("Can't bind socket: %s\n", error->message); return 1; } if (!use_udp) { if (!g_socket_listen (socket, &error)) { g_printerr ("Can't listen on socket: %s\n", error->message); return 1; } g_print ("listening on port %d...\n", port); ensure_condition (socket, "accept", cancellable, G_IO_IN); new_socket = g_socket_accept (socket, &error); if (!new_socket) { g_printerr ("Error accepting socket: %s\n", error->message); return 1; } if (non_blocking) g_socket_set_blocking (new_socket, FALSE); address = g_socket_get_remote_address (new_socket, &error); if (!address) { g_printerr ("Error getting remote address: %s\n", error->message); return 1; } g_print ("got a new connection from %s (blocking: %d)\n", socket_address_to_string (address), g_socket_get_blocking (new_socket)); recv_socket = new_socket; } else { recv_socket = socket; new_socket = NULL; } while (TRUE) { gchar buffer[4096] = { }; gssize size; gsize to_send; ensure_condition (recv_socket, "receive", cancellable, G_IO_IN); if (use_udp) size = g_socket_receive_from (recv_socket, &address, buffer, sizeof buffer, &error); else size = g_socket_receive (recv_socket, buffer, sizeof buffer, &error); if (size < 0) { g_printerr ("Error receiving from socket: %s\n", error->message); return 1; } if (size == 0) break; g_print ("received %" G_GSSIZE_FORMAT " bytes of data", size); if (use_udp) g_print (" from %s", socket_address_to_string (address)); g_print ("\n"); if (verbose) g_print ("-------------------------\n" "%.*s\n" "-------------------------\n", (int)size, buffer); to_send = size; while (to_send > 0) { ensure_condition (recv_socket, "send", cancellable, G_IO_OUT); if (use_udp) size = g_socket_send_to (recv_socket, address, buffer, to_send, &error); else size = g_socket_send (recv_socket, buffer, to_send, &error); if (size < 0) { if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK)) { g_print ("socket send would block, handling\n"); g_error_free (error); error = NULL; continue; } else { g_printerr ("Error sending to socket: %s\n", error->message); return 1; } } g_print ("sent %" G_GSSIZE_FORMAT " bytes of data\n", size); if (size == 0) { g_printerr ("Unexpected short write\n"); return 1; } to_send -= size; } } g_print ("connection closed\n"); if (new_socket) { if (!g_socket_close (new_socket, &error)) { g_printerr ("Error closing connection socket: %s\n", error->message); return 1; } g_object_unref (G_OBJECT (new_socket)); } if (!g_socket_close (socket, &error)) { g_printerr ("Error closing master socket: %s\n", error->message); return 1; } g_object_unref (G_OBJECT (socket)); return 0; }
int main (int argc, char *argv[]) { GSocket *socket; GSocketAddress *src_address; GSocketAddress *address; GSocketType socket_type; GSocketFamily socket_family; GError *error = NULL; GOptionContext *context; GCancellable *cancellable; GSocketAddressEnumerator *enumerator; GSocketConnectable *connectable; g_thread_init (NULL); g_type_init (); context = g_option_context_new (" <hostname>[:port] - Test GSocket client stuff"); g_option_context_add_main_entries (context, cmd_entries, NULL); if (!g_option_context_parse (context, &argc, &argv, &error)) { g_printerr ("%s: %s\n", argv[0], error->message); return 1; } if (argc != 2) { g_printerr ("%s: %s\n", argv[0], "Need to specify hostname / unix socket name"); return 1; } if (cancel_timeout) { cancellable = g_cancellable_new (); g_thread_create (cancel_thread, cancellable, FALSE, NULL); } else { cancellable = NULL; } loop = g_main_loop_new (NULL, FALSE); if (use_udp) socket_type = G_SOCKET_TYPE_DATAGRAM; else socket_type = G_SOCKET_TYPE_STREAM; if (unix_socket) socket_family = G_SOCKET_FAMILY_UNIX; else socket_family = G_SOCKET_FAMILY_IPV4; socket = g_socket_new (socket_family, socket_type, 0, &error); if (socket == NULL) { g_printerr ("%s: %s\n", argv[0], error->message); return 1; } if (read_timeout) g_socket_set_timeout (socket, read_timeout); if (unix_socket) { GSocketAddress *addr; addr = socket_address_from_string (argv[1]); if (addr == NULL) { g_printerr ("%s: Could not parse '%s' as unix socket name\n", argv[0], argv[1]); return 1; } connectable = G_SOCKET_CONNECTABLE (addr); } else { connectable = g_network_address_parse (argv[1], 7777, &error); if (connectable == NULL) { g_printerr ("%s: %s\n", argv[0], error->message); return 1; } } enumerator = g_socket_connectable_enumerate (connectable); while (TRUE) { address = g_socket_address_enumerator_next (enumerator, cancellable, &error); if (address == NULL) { if (error == NULL) g_printerr ("%s: No more addresses to try\n", argv[0]); else g_printerr ("%s: %s\n", argv[0], error->message); return 1; } if (g_socket_connect (socket, address, cancellable, &error)) break; g_printerr ("%s: Connection to %s failed: %s, trying next\n", argv[0], socket_address_to_string (address), error->message); g_error_free (error); error = NULL; g_object_unref (address); } g_object_unref (enumerator); g_object_unref (connectable); g_print ("Connected to %s\n", socket_address_to_string (address)); /* TODO: Test non-blocking connect */ if (non_blocking) g_socket_set_blocking (socket, FALSE); src_address = g_socket_get_local_address (socket, &error); if (!src_address) { g_printerr ("Error getting local address: %s\n", error->message); return 1; } g_print ("local address: %s\n", socket_address_to_string (src_address)); g_object_unref (src_address); while (TRUE) { gchar buffer[4096]; gssize size; gsize to_send; if (fgets (buffer, sizeof buffer, stdin) == NULL) break; to_send = strlen (buffer); while (to_send > 0) { ensure_condition (socket, "send", cancellable, G_IO_OUT); if (use_udp) size = g_socket_send_to (socket, address, buffer, to_send, cancellable, &error); else size = g_socket_send (socket, buffer, to_send, cancellable, &error); if (size < 0) { if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK)) { g_print ("socket send would block, handling\n"); g_error_free (error); error = NULL; continue; } else { g_printerr ("Error sending to socket: %s\n", error->message); return 1; } } g_print ("sent %" G_GSSIZE_FORMAT " bytes of data\n", size); if (size == 0) { g_printerr ("Unexpected short write\n"); return 1; } to_send -= size; } ensure_condition (socket, "receive", cancellable, G_IO_IN); if (use_udp) size = g_socket_receive_from (socket, &src_address, buffer, sizeof buffer, cancellable, &error); else size = g_socket_receive (socket, buffer, sizeof buffer, cancellable, &error); if (size < 0) { g_printerr ("Error receiving from socket: %s\n", error->message); return 1; } if (size == 0) break; g_print ("received %" G_GSSIZE_FORMAT " bytes of data", size); if (use_udp) g_print (" from %s", socket_address_to_string (src_address)); g_print ("\n"); if (verbose) g_print ("-------------------------\n" "%.*s" "-------------------------\n", (int)size, buffer); } g_print ("closing socket\n"); if (!g_socket_close (socket, &error)) { g_printerr ("Error closing master socket: %s\n", error->message); return 1; } g_object_unref (G_OBJECT (socket)); g_object_unref (G_OBJECT (address)); return 0; }
static gboolean _read_memory (ArvGvDeviceIOData *io_data, guint32 address, guint32 size, void *buffer, GError **error) { ArvGvcpPacket *packet; size_t packet_size; size_t answer_size; int count; unsigned int n_retries = 0; gboolean success = FALSE; answer_size = arv_gvcp_packet_get_read_memory_ack_size (size); g_return_val_if_fail (answer_size <= ARV_GV_DEVICE_BUFFER_SIZE, FALSE); g_mutex_lock (io_data->mutex); packet = arv_gvcp_packet_new_read_memory_cmd (address, ((size + sizeof (guint32) - 1) / sizeof (guint32)) * sizeof (guint32), 0, &packet_size); do { io_data->packet_id = arv_gvcp_next_packet_id (io_data->packet_id); arv_gvcp_packet_set_packet_id (packet, io_data->packet_id); arv_gvcp_packet_debug (packet, ARV_DEBUG_LEVEL_LOG); g_socket_send_to (io_data->socket, io_data->device_address, (const char *) packet, packet_size, NULL, NULL); if (g_poll (&io_data->poll_in_event, 1, io_data->gvcp_timeout_ms) > 0) { count = g_socket_receive (io_data->socket, io_data->buffer, ARV_GV_DEVICE_BUFFER_SIZE, NULL, NULL); if (count >= answer_size) { ArvGvcpPacket *ack_packet = io_data->buffer; ArvGvcpPacketType packet_type; ArvGvcpCommand command; guint16 packet_id; arv_gvcp_packet_debug (ack_packet, ARV_DEBUG_LEVEL_LOG); packet_type = arv_gvcp_packet_get_packet_type (ack_packet); command = arv_gvcp_packet_get_command (ack_packet); packet_id = arv_gvcp_packet_get_packet_id (ack_packet); if (packet_type == ARV_GVCP_PACKET_TYPE_ACK && command == ARV_GVCP_COMMAND_READ_MEMORY_ACK && packet_id == io_data->packet_id) { memcpy (buffer, arv_gvcp_packet_get_read_memory_ack_data (ack_packet), size); success = TRUE; } else arv_gvcp_packet_debug (ack_packet, ARV_DEBUG_LEVEL_WARNING); } } n_retries++; } while (!success && n_retries < io_data->gvcp_n_retries); arv_gvcp_packet_free (packet); g_mutex_unlock (io_data->mutex); if (!success) { if (error != NULL && *error == NULL) *error = g_error_new (ARV_DEVICE_ERROR, ARV_DEVICE_STATUS_TIMEOUT, "[ArvDevice::read_memory] Timeout"); } return success; }
gboolean _write_register (ArvGvDeviceIOData *io_data, guint32 address, guint32 value, GError **error) { ArvGvcpPacket *packet; size_t packet_size; int count; unsigned int n_retries = 0; gboolean success = FALSE; g_mutex_lock (io_data->mutex); packet = arv_gvcp_packet_new_write_register_cmd (address, value, io_data->packet_id, &packet_size); do { io_data->packet_id = arv_gvcp_next_packet_id (io_data->packet_id); arv_gvcp_packet_set_packet_id (packet, io_data->packet_id); arv_gvcp_packet_debug (packet, ARV_DEBUG_LEVEL_LOG); g_socket_send_to (io_data->socket, io_data->device_address, (const char *) packet, packet_size, NULL, NULL); if (g_poll (&io_data->poll_in_event, 1, io_data->gvcp_timeout_ms) > 0) { count = g_socket_receive (io_data->socket, io_data->buffer, ARV_GV_DEVICE_BUFFER_SIZE, NULL, NULL); if (count > 0) { ArvGvcpPacket *ack_packet = io_data->buffer; ArvGvcpPacketType packet_type; ArvGvcpCommand command; guint16 packet_id; arv_gvcp_packet_debug (ack_packet, ARV_DEBUG_LEVEL_LOG); packet_type = arv_gvcp_packet_get_packet_type (ack_packet); command = arv_gvcp_packet_get_command (ack_packet); packet_id = arv_gvcp_packet_get_packet_id (ack_packet); arv_log_gvcp ("%d, %d, %d", packet_type, command, packet_id); if (packet_type == ARV_GVCP_PACKET_TYPE_ACK && command == ARV_GVCP_COMMAND_WRITE_REGISTER_ACK && packet_id == io_data->packet_id) success = TRUE; else arv_gvcp_packet_debug (ack_packet, ARV_DEBUG_LEVEL_WARNING); } } n_retries++; } while (!success && n_retries < io_data->gvcp_n_retries); arv_gvcp_packet_free (packet); g_mutex_unlock (io_data->mutex); if (!success) { if (error != NULL && *error == NULL) *error = g_error_new (ARV_DEVICE_ERROR, ARV_DEVICE_STATUS_TIMEOUT, "[ArvDevice::write_register] Timeout"); } return success; }
int main (int argc, char *argv[]) { GSocket *socket; GSocketAddress *address; GError *error = NULL; GOptionContext *context; GCancellable *cancellable; GIOStream *connection; GInputStream *istream; GOutputStream *ostream; GSocketAddress *src_address; GTlsCertificate *certificate = NULL; gint i; address = NULL; connection = NULL; context = g_option_context_new (" <hostname>[:port] - Test GSocket client stuff"); g_option_context_add_main_entries (context, cmd_entries, NULL); if (!g_option_context_parse (context, &argc, &argv, &error)) { g_printerr ("%s: %s\n", argv[0], error->message); return 1; } if (argc != 2) { g_printerr ("%s: %s\n", argv[0], "Need to specify hostname / unix socket name"); return 1; } if (use_udp && tls) { g_printerr ("DTLS (TLS over UDP) is not supported"); return 1; } if (cancel_timeout) { GThread *thread; cancellable = g_cancellable_new (); thread = g_thread_new ("cancel", cancel_thread, cancellable); g_thread_unref (thread); } else { cancellable = NULL; } loop = g_main_loop_new (NULL, FALSE); for (i = 0; i < 2; i++) { if (make_connection (argv[1], certificate, cancellable, &socket, &address, &connection, &istream, &ostream, &error)) break; if (g_error_matches (error, G_TLS_ERROR, G_TLS_ERROR_CERTIFICATE_REQUIRED)) { g_clear_error (&error); certificate = lookup_client_certificate (G_TLS_CLIENT_CONNECTION (connection), &error); if (certificate != NULL) continue; } g_printerr ("%s: %s", argv[0], error->message); return 1; } /* TODO: Test non-blocking connect/handshake */ if (non_blocking) g_socket_set_blocking (socket, FALSE); while (TRUE) { gchar buffer[4096]; gssize size; gsize to_send; if (fgets (buffer, sizeof buffer, stdin) == NULL) break; to_send = strlen (buffer); while (to_send > 0) { if (use_udp) { ensure_socket_condition (socket, G_IO_OUT, cancellable); size = g_socket_send_to (socket, address, buffer, to_send, cancellable, &error); } else { ensure_connection_condition (connection, G_IO_OUT, cancellable); size = g_output_stream_write (ostream, buffer, to_send, cancellable, &error); } if (size < 0) { if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK)) { g_print ("socket send would block, handling\n"); g_error_free (error); error = NULL; continue; } else { g_printerr ("Error sending to socket: %s\n", error->message); return 1; } } g_print ("sent %" G_GSSIZE_FORMAT " bytes of data\n", size); if (size == 0) { g_printerr ("Unexpected short write\n"); return 1; } to_send -= size; } if (use_udp) { ensure_socket_condition (socket, G_IO_IN, cancellable); size = g_socket_receive_from (socket, &src_address, buffer, sizeof buffer, cancellable, &error); } else { ensure_connection_condition (connection, G_IO_IN, cancellable); size = g_input_stream_read (istream, buffer, sizeof buffer, cancellable, &error); } if (size < 0) { g_printerr ("Error receiving from socket: %s\n", error->message); return 1; } if (size == 0) break; g_print ("received %" G_GSSIZE_FORMAT " bytes of data", size); if (use_udp) g_print (" from %s", socket_address_to_string (src_address)); g_print ("\n"); if (verbose) g_print ("-------------------------\n" "%.*s" "-------------------------\n", (int)size, buffer); } g_print ("closing socket\n"); if (connection) { if (!g_io_stream_close (connection, cancellable, &error)) { g_printerr ("Error closing connection: %s\n", error->message); return 1; } g_object_unref (connection); } else { if (!g_socket_close (socket, &error)) { g_printerr ("Error closing master socket: %s\n", error->message); return 1; } } g_object_unref (socket); g_object_unref (address); return 0; }
int main (int argc, char *argv[]) { GSocket *socket, *new_socket, *recv_socket; GSocketAddress *src_address; GSocketAddress *address; GSocketType socket_type; GSocketFamily socket_family; GError *error = NULL; GOptionContext *context; GCancellable *cancellable; char *display_addr; GTlsCertificate *tlscert = NULL; GIOStream *connection; GInputStream *istream; GOutputStream *ostream; g_type_init (); context = g_option_context_new (" - Test GSocket server stuff"); g_option_context_add_main_entries (context, cmd_entries, NULL); if (!g_option_context_parse (context, &argc, &argv, &error)) { g_printerr ("%s: %s\n", argv[0], error->message); return 1; } if (unix_socket && argc != 2) { g_printerr ("%s: %s\n", argv[0], "Need to specify unix socket name"); return 1; } if (cancel_timeout) { GThread *thread; cancellable = g_cancellable_new (); thread = g_thread_new ("cancel", cancel_thread, cancellable); g_thread_unref (thread); } else { cancellable = NULL; } if (tls_cert_file) { if (use_udp) { g_printerr ("DTLS (TLS over UDP) is not supported"); return 1; } tlscert = g_tls_certificate_new_from_file (tls_cert_file, &error); if (!tlscert) { g_printerr ("Could not read server certificate '%s': %s\n", tls_cert_file, error->message); return 1; } } loop = g_main_loop_new (NULL, FALSE); if (use_udp) socket_type = G_SOCKET_TYPE_DATAGRAM; else socket_type = G_SOCKET_TYPE_STREAM; if (unix_socket) socket_family = G_SOCKET_FAMILY_UNIX; else socket_family = G_SOCKET_FAMILY_IPV4; socket = g_socket_new (socket_family, socket_type, 0, &error); if (socket == NULL) { g_printerr ("%s: %s\n", argv[0], error->message); return 1; } if (non_blocking) g_socket_set_blocking (socket, FALSE); if (unix_socket) { src_address = socket_address_from_string (argv[1]); if (src_address == NULL) { g_printerr ("%s: Could not parse '%s' as unix socket name\n", argv[0], argv[1]); return 1; } } else { src_address = g_inet_socket_address_new (g_inet_address_new_any (G_SOCKET_FAMILY_IPV4), port); } if (!g_socket_bind (socket, src_address, !dont_reuse_address, &error)) { g_printerr ("Can't bind socket: %s\n", error->message); return 1; } g_object_unref (src_address); if (!use_udp) { if (!g_socket_listen (socket, &error)) { g_printerr ("Can't listen on socket: %s\n", error->message); return 1; } address = g_socket_get_local_address (socket, &error); if (!address) { g_printerr ("Error getting local address: %s\n", error->message); return 1; } display_addr = socket_address_to_string (address); g_print ("listening on %s...\n", display_addr); g_free (display_addr); ensure_socket_condition (socket, G_IO_IN, cancellable); new_socket = g_socket_accept (socket, cancellable, &error); if (!new_socket) { g_printerr ("Error accepting socket: %s\n", error->message); return 1; } if (non_blocking) g_socket_set_blocking (new_socket, FALSE); if (read_timeout) g_socket_set_timeout (new_socket, read_timeout); address = g_socket_get_remote_address (new_socket, &error); if (!address) { g_printerr ("Error getting remote address: %s\n", error->message); return 1; } display_addr = socket_address_to_string (address); g_print ("got a new connection from %s\n", display_addr); g_free(display_addr); g_object_unref (address); recv_socket = new_socket; connection = G_IO_STREAM (g_socket_connection_factory_create_connection (recv_socket)); g_object_unref (new_socket); } else { recv_socket = socket; connection = NULL; } if (tlscert) { GIOStream *tls_conn; tls_conn = g_tls_server_connection_new (connection, tlscert, &error); if (!tls_conn) { g_printerr ("Could not create TLS connection: %s\n", error->message); return 1; } if (!g_tls_connection_handshake (G_TLS_CONNECTION (tls_conn), cancellable, &error)) { g_printerr ("Error during TLS handshake: %s\n", error->message); return 1; } g_object_unref (connection); connection = tls_conn; } if (connection) { istream = g_io_stream_get_input_stream (connection); ostream = g_io_stream_get_output_stream (connection); } else { g_assert (use_udp); istream = NULL; ostream = NULL; } while (TRUE) { gchar buffer[4096]; gssize size; gsize to_send; if (use_udp) { ensure_socket_condition (recv_socket, G_IO_IN, cancellable); size = g_socket_receive_from (recv_socket, &address, buffer, sizeof buffer, cancellable, &error); } else { ensure_connection_condition (connection, G_IO_IN, cancellable); size = g_input_stream_read (istream, buffer, sizeof buffer, cancellable, &error); } if (size < 0) { g_printerr ("Error receiving from socket: %s\n", error->message); return 1; } if (size == 0) break; g_print ("received %" G_GSSIZE_FORMAT " bytes of data", size); if (use_udp) g_print (" from %s", socket_address_to_string (address)); g_print ("\n"); if (verbose) g_print ("-------------------------\n" "%.*s\n" "-------------------------\n", (int)size, buffer); to_send = size; #ifdef __QNXNTO__ if (delay_) #else if (delay) #endif { #ifdef __QNXNTO__ if (verbose) g_print ("delaying %d seconds before response\n", delay_); g_usleep (1000 * 1000 * delay_); #else if (verbose) g_print ("delaying %d seconds before response\n", delay); g_usleep (1000 * 1000 * delay); #endif } while (to_send > 0) { if (use_udp) { ensure_socket_condition (recv_socket, G_IO_OUT, cancellable); size = g_socket_send_to (recv_socket, address, buffer, to_send, cancellable, &error); } else { ensure_connection_condition (connection, G_IO_OUT, cancellable); size = g_output_stream_write (ostream, buffer, to_send, cancellable, &error); } if (size < 0) { if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK)) { g_print ("socket send would block, handling\n"); g_error_free (error); error = NULL; continue; } else { g_printerr ("Error sending to socket: %s\n", error->message); return 1; } } g_print ("sent %" G_GSSIZE_FORMAT " bytes of data\n", size); if (size == 0) { g_printerr ("Unexpected short write\n"); return 1; } to_send -= size; } } g_print ("connection closed\n"); if (connection) { if (!g_io_stream_close (connection, NULL, &error)) { g_printerr ("Error closing connection stream: %s\n", error->message); return 1; } g_object_unref (connection); } if (!g_socket_close (socket, &error)) { g_printerr ("Error closing master socket: %s\n", error->message); return 1; } g_object_unref (socket); return 0; }
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; }