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