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;
}
