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); }
/* create a socket for sending to remote machine */ static gboolean gst_udpsrc_open (GstUDPSrc * src) { GInetAddress *addr, *bind_addr; GSocketAddress *bind_saddr; GError *err = NULL; gst_udpsrc_create_cancellable (src); if (src->socket == NULL) { /* need to allocate a socket */ GST_DEBUG_OBJECT (src, "allocating socket for %s:%d", src->address, src->port); addr = gst_udpsrc_resolve (src, src->address); if (!addr) goto name_resolve; 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); /* On Windows it's not possible to bind to a multicast address * but the OS will make sure to filter out all packets that * arrive not for the multicast address the socket joined. * * On Linux and others it is necessary to bind to a multicast * address to let the OS filter out all packets that are received * on the same port but for different addresses than the multicast * address */ #ifdef G_OS_WIN32 if (g_inet_address_get_is_multicast (addr)) bind_addr = g_inet_address_new_any (g_inet_address_get_family (addr)); else #endif 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->address); 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); } src->allocator = NULL; gst_allocation_params_init (&src->params); src->max_size = 0; return TRUE; /* ERRORS */ name_resolve: { 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_close (src); return FALSE; } membership: { GST_ELEMENT_ERROR (src, RESOURCE, SETTINGS, (NULL), ("could add membership: %s", err->message)); g_clear_error (&err); gst_udpsrc_close (src); return FALSE; } getsockname_error: { GST_ELEMENT_ERROR (src, RESOURCE, SETTINGS, (NULL), ("getsockname failed: %s", err->message)); g_clear_error (&err); gst_udpsrc_close (src); return FALSE; } }
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 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; }
static gboolean on_socket_input (GSocket *socket, GIOCondition condition, gpointer user_data) { CockpitRequest *request = user_data; guchar first_byte; GInputVector vector[1] = { { &first_byte, 1 } }; gint flags = G_SOCKET_MSG_PEEK; gboolean redirect_tls; gboolean is_tls; GSocketAddress *addr; GInetAddress *inet; GError *error = NULL; GIOStream *tls_stream; gssize num_read; num_read = g_socket_receive_message (socket, NULL, /* out GSocketAddress */ vector, 1, NULL, /* out GSocketControlMessage */ NULL, /* out num_messages */ &flags, NULL, /* GCancellable* */ &error); if (num_read < 0) { /* Just wait and try again */ if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK)) { g_error_free (error); return TRUE; } if (!should_suppress_request_error (error)) g_warning ("couldn't read from socket: %s", error->message); cockpit_request_finish (request); g_error_free (error); return FALSE; } is_tls = TRUE; redirect_tls = FALSE; /* * TLS streams are guaranteed to start with octet 22.. this way we can distinguish them * from regular HTTP requests */ if (first_byte != 22 && first_byte != 0x80) { is_tls = FALSE; redirect_tls = TRUE; addr = g_socket_connection_get_remote_address (G_SOCKET_CONNECTION (request->io), NULL); if (G_IS_INET_SOCKET_ADDRESS (addr)) { inet = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (addr)); redirect_tls = !g_inet_address_get_is_loopback (inet); } g_clear_object (&addr); } if (is_tls) { tls_stream = g_tls_server_connection_new (request->io, request->web_server->certificate, &error); if (tls_stream == NULL) { g_warning ("couldn't create new TLS stream: %s", error->message); cockpit_request_finish (request); g_error_free (error); return FALSE; } g_object_unref (request->io); request->io = G_IO_STREAM (tls_stream); } else if (redirect_tls) { request->delayed_reply = 301; } start_request_input (request); /* No longer run *this* source */ return FALSE; }
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; }
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 g_network_monitor_base_can_reach (GNetworkMonitor *monitor, GSocketConnectable *connectable, GCancellable *cancellable, GError **error) { GNetworkMonitorBasePrivate *priv = G_NETWORK_MONITOR_BASE (monitor)->priv; GSocketAddressEnumerator *enumerator; GSocketAddress *addr; if (priv->have_ipv4_default_route && priv->have_ipv6_default_route) return TRUE; if (priv->networks->len == 0) { g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NETWORK_UNREACHABLE, _("Network unreachable")); return FALSE; } enumerator = g_socket_connectable_proxy_enumerate (connectable); addr = g_socket_address_enumerator_next (enumerator, cancellable, error); if (!addr) { /* Either the user cancelled, or DNS resolution failed */ g_object_unref (enumerator); return FALSE; } while (addr) { if (G_IS_INET_SOCKET_ADDRESS (addr)) { GInetAddress *iaddr; int i; iaddr = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (addr)); for (i = 0; i < priv->networks->len; i++) { if (g_inet_address_mask_matches (priv->networks->pdata[i], iaddr)) { g_object_unref (addr); g_object_unref (enumerator); return TRUE; } } } g_object_unref (addr); addr = g_socket_address_enumerator_next (enumerator, cancellable, error); } g_object_unref (enumerator); if (error && !*error) { g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_HOST_UNREACHABLE, _("Host unreachable")); } return FALSE; }
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->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_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->priv->frame_id, block_id, data_size, ((char *) image_buffer->priv->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->priv->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; }
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_insert (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_insert (gv_interface->priv->devices, device_infos->user_name, device_infos); } arv_gv_interface_device_infos_ref (device_infos); g_hash_table_insert (gv_interface->priv->devices, device_infos->mac_string, device_infos); arv_gv_interface_device_infos_unref (device_infos); } } } while (count > 0); } } while (1); }
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); 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 ("[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_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; }
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 do_lookup_by_name (GTask *task, gpointer source_object, gpointer task_data, GCancellable *cancellable) { const char *hostname = task_data; struct addrinfo *res = NULL; GList *addresses; gint retval; retval = getaddrinfo (hostname, NULL, &addrinfo_hints, &res); if (retval == 0) { struct addrinfo *ai; GSocketAddress *sockaddr; GInetAddress *addr; addresses = NULL; for (ai = res; ai; ai = ai->ai_next) { sockaddr = g_socket_address_new_from_native (ai->ai_addr, ai->ai_addrlen); if (!sockaddr) continue; if (!G_IS_INET_SOCKET_ADDRESS (sockaddr)) { g_clear_object (&sockaddr); continue; } addr = g_object_ref (g_inet_socket_address_get_address ((GInetSocketAddress *)sockaddr)); addresses = g_list_prepend (addresses, addr); g_object_unref (sockaddr); } if (addresses != NULL) { addresses = g_list_reverse (addresses); g_task_return_pointer (task, addresses, (GDestroyNotify)g_resolver_free_addresses); } else { /* All addresses failed to be converted to GSocketAddresses. */ g_task_return_new_error (task, G_RESOLVER_ERROR, G_RESOLVER_ERROR_NOT_FOUND, _("Error resolving “%s”: %s"), hostname, _("No valid addresses were found")); } } else { g_task_return_new_error (task, G_RESOLVER_ERROR, g_resolver_error_from_addrinfo_error (retval), _("Error resolving “%s”: %s"), hostname, gai_strerror (retval)); } if (res) freeaddrinfo (res); }
//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 ArvStream * arv_gv_device_create_stream (ArvDevice *device, ArvStreamCallback callback, void *user_data) { ArvGvDevice *gv_device = ARV_GV_DEVICE (device); ArvGvDeviceIOData *io_data = gv_device->priv->io_data; ArvStream *stream; const guint8 *address_bytes; guint32 stream_port; guint packet_size; guint32 n_stream_channels; GInetAddress *interface_address; GInetAddress *device_address; arv_device_read_register (device, ARV_GVBS_N_STREAM_CHANNELS_OFFSET, &n_stream_channels, NULL); arv_debug_device ("[GvDevice::create_stream] Number of stream channels = %d", n_stream_channels); if (n_stream_channels < 1) return NULL; if (!io_data->is_controller) { arv_warning_device ("[GvDevice::create_stream] Can't create stream without control access"); return NULL; } interface_address = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (io_data->interface_address)); device_address = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (io_data->device_address)); address_bytes = g_inet_address_to_bytes (interface_address); /* On some cameras, the default packet size after reset is incorrect. * So, if the value is obviously incorrect, set it to a default size. */ packet_size = arv_gv_device_get_packet_size (gv_device); if (packet_size <= ARV_GVSP_PACKET_PROTOCOL_OVERHEAD) { arv_gv_device_set_packet_size (gv_device, ARV_GV_DEVICE_GVSP_PACKET_SIZE_DEFAULT); arv_debug_device ("[GvDevice::create_stream] Packet size set to default value (%d)", ARV_GV_DEVICE_GVSP_PACKET_SIZE_DEFAULT); } packet_size = arv_gv_device_get_packet_size (gv_device); arv_debug_device ("[GvDevice::create_stream] Packet size = %d byte(s)", packet_size); stream = arv_gv_stream_new (device_address, 0, callback, user_data, arv_gv_device_get_timestamp_tick_frequency (gv_device), packet_size); stream_port = arv_gv_stream_get_port (ARV_GV_STREAM (stream)); if (!arv_device_write_register (device, ARV_GVBS_STREAM_CHANNEL_0_IP_ADDRESS_OFFSET, g_htonl(*((guint32 *) address_bytes)), NULL) || !arv_device_write_register (device, ARV_GVBS_STREAM_CHANNEL_0_PORT_OFFSET, stream_port, NULL)) { arv_warning_device ("[GvDevice::create_stream] Stream configuration failed"); g_object_unref (stream); return NULL; } if (!gv_device->priv->is_packet_resend_supported) g_object_set (stream, "packet-resend", ARV_GV_STREAM_PACKET_RESEND_NEVER, NULL); arv_debug_device ("[GvDevice::create_stream] Stream port = %d", stream_port); return stream; }