gboolean janus_source_send_rtcp_src_received(GSocket *socket, GIOCondition condition, janus_source_rtcp_cbk_data * data)
{
char buf[512];
gssize len;
janus_source_session * session = (janus_source_session*)data->session;
if (!session) {
JANUS_LOG(LOG_ERR, "janus_source_send_rtcp_src_received: session is NULL\n");
return TRUE;
}
len = g_socket_receive(socket, (gchar*)buf, sizeof(buf), NULL, NULL);
if (len > 0) {
if (janus_rtcp_has_pli(buf, len))
{
JANUS_LOG(LOG_VERB, "Source: received PLI\n");
}
JANUS_LOG(LOG_HUGE, "%s RTCP sent; len=%ld\n", data->is_video ? "Video" : "Audio", len);
gateway->relay_rtcp(session->handle, data->is_video, buf, len);
}
return TRUE;
}
/*
net_read ()
Attempts to read datalen bytes from the network connection
Returns number of bytes read or <=0 if error is encountered.
*/
static gint32
net_read (MCACnxn *cnxn, void *data, guint32 datalen)
{
gint32 retsize;
retsize = read_data(cnxn->conn_priv, data, datalen);
#if 0
GError *error;
assert(cnxn != NULL);
#ifdef USE_IO_STREAM
assert(cnxn->net_in_stream != NULL);
retsize = g_input_stream_read(cnxn->net_in_stream, data, datalen, NULL, &error);
#else
assert(cnxn->gsocket != NULL);
retsize = g_socket_receive(cnxn->gsocket, data, datalen, NULL, &error);
#endif
if (retsize < 0){
DEBUG_PRINT("net_read(): Error [%s]\n", error->message);
g_error_free(error);
}
else{
DEBUG_PRINT("net_read(): read [%d bytes]\n", retsize);
}
#endif
return retsize;
}
static gboolean
pk_socket_example_accept_connection_cb (GSocket *socket, GIOCondition condition, gpointer user_data)
{
GError *error = NULL;
gsize len;
gchar buffer[1024];
gboolean ret = TRUE;
GMainLoop *loop = (GMainLoop *) user_data;
/* the helper process exited */
if ((condition & G_IO_HUP) > 0) {
g_warning ("socket was disconnected");
g_main_loop_quit (loop);
ret = FALSE;
goto out;
}
/* there is data */
if ((condition & G_IO_IN) > 0) {
len = g_socket_receive (socket, buffer, 1024, NULL, &error);
if (error != NULL) {
g_warning ("failed to get data: %s", error->message);
g_error_free (error);
ret = FALSE;
goto out;
}
if (len == 0)
goto out;
g_debug ("got data: %s : %" G_GSIZE_FORMAT, buffer, len);
}
out:
return ret;
}
/* coroutine context */
static int spice_channel_read_wire(SpiceChannel *channel, void *data, size_t len)
{
spice_channel *c = channel->priv;
int ret;
GIOCondition cond;
reread:
if (c->has_error) return 0; /* has_error is set by disconnect(), return no error */
cond = 0;
if (c->tls) {
ret = SSL_read(c->ssl, data, len);
if (ret < 0) {
ret = SSL_get_error(c->ssl, ret);
if (ret == SSL_ERROR_WANT_READ)
cond |= G_IO_IN;
if (ret == SSL_ERROR_WANT_WRITE)
cond |= G_IO_OUT;
ret = -1;
}
} else {
GError *error = NULL;
ret = g_socket_receive(c->sock, data, len, NULL, &error);
if (ret < 0) {
if (g_error_matches(error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK)) {
cond = G_IO_IN;
} else {
SPICE_DEBUG("Read error %s", error->message);
}
g_clear_error(&error);
ret = -1;
}
}
if (ret == -1) {
if (cond != 0) {
if (c->wait_interruptable) {
if (!g_io_wait_interruptable(&c->wait, c->sock, cond)) {
// SPICE_DEBUG("Read blocking interrupted %d", priv->has_error);
return -EAGAIN;
}
} else {
g_io_wait(c->sock, cond);
}
goto reread;
} else {
c->has_error = TRUE;
return -errno;
}
}
if (ret == 0) {
SPICE_DEBUG("Closing the connection: spice_channel_read() - ret=0");
c->has_error = TRUE;
return 0;
}
return ret;
}
static ssize_t
read_handle (GSocket * srchandle, void *buf, size_t count)
{
gssize ret;
ret = g_socket_receive (srchandle, buf, count, NULL, NULL);
return ret;
}
GInetAddress *interface_getConfiguredAddress(struct node *n)
{
GInetAddress *ret = NULL;
GSocket *s = n->ubnetd;
if( s != NULL ){
if( g_socket_condition_check(s, G_IO_IN) & G_IO_IN ){
gchar buf[1];
g_socket_receive(s,buf,1,NULL,NULL);
if( buf[0] == 'A' )
ret = n->netadr;
g_socket_close(s, NULL);
g_object_unref(s);
n->ubnetd = NULL;
}
}
return ret;
}
int main(int argc, char *argv[])
{
GError *err = NULL;
GSocket *serv_gsock;
GSocketAddress *gaddr;
struct sockaddr_in addr;
/* Create socket */
serv_gsock = g_socket_new(G_SOCKET_FAMILY_IPV4,
G_SOCKET_TYPE_STREAM,
0,
&err);
if (!serv_gsock) {
printf("GSocket creation failure: %s\n", err->message);
g_clear_error(&err);
}
/* Bind to 127.0.0.1 */
bzero(&addr, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(10086);
inet_pton(AF_INET, "127.0.0.1", &addr.sin_addr);
gaddr = g_socket_address_new_from_native(&addr, sizeof(addr));
if (!g_socket_bind(serv_gsock, gaddr, TRUE, &err)) {
printf("GSocket bind failure: %s\n", err->message);
g_clear_error(&err);
}
/* Listen */
if (!g_socket_listen(serv_gsock, &err)) {
printf("GSocket listen failure: %s\n", err->message);
g_clear_error(&err);
}
/* Accept */
gchar buffer[256];
gsize bytes_read;
GSocket *clnt_gsock;
clnt_gsock = g_socket_accept(serv_gsock, NULL, &err);
bytes_read = g_socket_receive(clnt_gsock, buffer, 256, NULL, &err);
printf("%u read: <%s>\n", (unsigned int)bytes_read, buffer);
return 0;
}
gboolean source_cb(GSocket *socket, GIOCondition condition, void *data)
{
int sym;
gchar chr;
GMainLoop *main_loop = data;
if (g_socket_receive(socket, &chr, 1, NULL, NULL) <= 0) {
g_main_loop_quit(main_loop);
return FALSE;
}
switch (chr) {
case 13: sym = FcitxKey_Return; break;
case 27: sym = FcitxKey_Escape; break;
case 127: sym = FcitxKey_BackSpace; break;
default: sym = chr; break;
}
fcitx_client_process_key_sync(client, sym, chr, 0, 0, 0);
return TRUE;
}
gint interface_removeAddress(struct node *n)
{
GError * e = NULL;
GInetAddress *lo = g_inet_address_new_loopback(
G_SOCKET_FAMILY_IPV6);
GSocketAddress *sa = g_inet_socket_address_new(
lo,
42);
GSocket *s = g_socket_new(G_SOCKET_FAMILY_IPV6,
G_SOCKET_TYPE_STREAM,
G_SOCKET_PROTOCOL_TCP,
&e);
if( e != NULL ){
syslog(LOG_ERR,"interface_popAddress: error while creating socket: %s\n", e->message);
g_error_free(e);
return -1;
}
g_socket_connect(s, sa, NULL, &e);
if( e != NULL ){
syslog(LOG_ERR,"interface_popAddress: error while connecting: %s\n", e->message);
g_error_free(e);
return -1;
}
g_socket_send(s,"D",1,NULL,NULL);
gchar *bytes = (gchar*)g_inet_address_to_bytes(n->netadr);
g_socket_send(s,bytes,16,NULL,NULL);
gchar buf[1];
g_socket_receive(s,buf,1,NULL,NULL);
g_socket_close(s,NULL);
g_object_unref(s);
return 0;
}
static gboolean
read_from_snapd (GSocket *socket,
GByteArray *buffer,
gsize *read_offset,
gsize size,
GCancellable *cancellable,
GError **error)
{
gssize n_read;
if (*read_offset + size > buffer->len)
g_byte_array_set_size (buffer, *read_offset + size + 1);
n_read = g_socket_receive (socket,
buffer->data + *read_offset,
size,
cancellable,
error);
if (n_read < 0)
return FALSE;
*read_offset += (gsize) n_read;
buffer->data[*read_offset] = '\0';
return TRUE;
}
gboolean moloch_http_read_cb(gint UNUSED(fd), GIOCondition cond, gpointer data) {
MolochConn_t *conn = data;
char buffer[0xffff];
int len;
GError *gerror = 0;
len = g_socket_receive(conn->conn, buffer, sizeof(buffer)-1, NULL, &gerror);
if (gerror || cond & (G_IO_HUP | G_IO_ERR) || len <= 0) {
if (gerror) {
LOG("ERROR: %s %p:%p Receive Error: %s", conn->name, (void*)conn, conn->request, gerror->message);
g_error_free(gerror);
} else if (cond & (G_IO_HUP | G_IO_ERR))
LOG("ERROR: %s %p:%p Lost connection to %s", conn->name, (void*)conn, conn->request, conn->name);
else if (len <= 0)
LOG("ERROR: %s %p:%p len: %d cond: %x", conn->name, (void*)conn, conn->request, len, cond);
else
LOG("ERROR HMM: %s %p:%p len: %d cond: %x", conn->name, (void*)conn, conn->request, len, cond);
if (conn == conn->server->syncConn) {
if (!conn->request) {
DEBUGCONN("AAA zerosync %s %p", conn->server->names[0], conn);
conn->server->syncConn = 0;
moloch_http_free_conn(conn, FALSE);
} else {
DEBUGCONN("AAA complete %s %p", conn->server->names[0], conn);
conn->hp_complete = 1;
}
return FALSE;
}
if (conn->request && conn->request->data) {
conn->server->inProgress--;
DLL_PUSH_HEAD(r_, &conn->server->requestQ, conn->request);
} else if (conn->request) {
conn->server->inProgress--;
// Must save, free, then call function because of recursive sync GETs
MolochResponse_cb func = conn->request->func;
gpointer uw = conn->request->uw;
MOLOCH_TYPE_FREE(MolochRequest_t, conn->request);
if (func) {
func(0, 0, uw);
}
}
moloch_http_free_conn(conn, TRUE);
return FALSE;
}
http_parser_execute(&conn->parser, &conn->server->parserSettings, buffer, len);
if (conn->hp_complete) {
gettimeofday(&conn->endTime, NULL);
if (config.logESRequests)
LOG("%s %ldms %ldms %ldms",
conn->line,
(conn->sendTime.tv_sec - conn->startTime.tv_sec)*1000 + (conn->sendTime.tv_usec - conn->startTime.tv_usec)/1000,
(conn->sentTime.tv_sec - conn->startTime.tv_sec)*1000 + (conn->sentTime.tv_usec - conn->startTime.tv_usec)/1000,
(conn->endTime.tv_sec - conn->startTime.tv_sec)*1000 + (conn->endTime.tv_usec - conn->startTime.tv_usec)/1000
);
conn->hp_data[conn->hp_len] = 0;
/* Must save, free, then call function because of recursive sync GETs */
MolochResponse_cb func = conn->request->func;
gpointer uw = conn->request->uw;
MOLOCH_TYPE_FREE(MolochRequest_t, conn->request);
conn->request = 0;
if (func) {
func((unsigned char*)conn->hp_data, conn->hp_len, uw);
}
if (conn == conn->server->syncConn) {
if (conn->doClose) {
DEBUGCONN("AAA zerosync %s %p", conn->server->names[0], conn);
conn->server->syncConn = 0;
moloch_http_free_conn(conn, FALSE);
return FALSE;
}
return TRUE;
}
// Not syncConn below this
if (conn->doClose) {
moloch_http_free_conn(conn, TRUE);
return FALSE;
}
conn->server->inProgress--;
DLL_PUSH_TAIL(e_, &conn->server->connQ, conn);
moloch_http_do_requests(conn->server);
}
return TRUE;
}
DasomMessage *dasom_recv_message (GSocket *socket)
{
g_debug (G_STRLOC ": %s", G_STRFUNC);
DasomMessage *message = dasom_message_new ();
GError *error = NULL;
gssize n_read = 0;
n_read = g_socket_receive (socket,
(gchar *) message->header,
dasom_message_get_header_size (),
NULL, &error);
if (G_UNLIKELY (n_read < dasom_message_get_header_size ()))
{
g_critical (G_STRLOC ": %s: received %"G_GSSIZE_FORMAT" less than %d",
G_STRFUNC, n_read, dasom_message_get_header_size ());
if (error)
{
g_critical (G_STRLOC ": %s: %s", G_STRFUNC, error->message);
g_error_free (error);
}
dasom_message_unref (message);
return NULL;
}
if (message->header->data_len > 0)
{
dasom_message_set_body (message,
g_malloc0 (message->header->data_len),
message->header->data_len,
g_free);
n_read = g_socket_receive (socket,
message->data,
message->header->data_len,
NULL, &error);
if (G_UNLIKELY (n_read < message->header->data_len))
{
g_critical (G_STRLOC ": %s: received %"G_GSSIZE_FORMAT" less than %d",
G_STRFUNC, n_read, message->header->data_len);
if (error)
{
g_critical (G_STRLOC ": %s: %s", G_STRFUNC, error->message);
g_error_free (error);
}
dasom_message_unref (message);
return NULL;
}
}
/* debug message */
const gchar *name = dasom_message_get_name (message);
if (name)
g_debug ("recv: %s, fd: %d", name, g_socket_get_fd (socket));
else
g_error (G_STRLOC ": unknown message type");
return message;
}
static GstFlowReturn
gst_tcp_mix_src_pad_read (GstTCPMixSrcPad * pad, GstBuffer ** outbuf)
{
GstTCPMixSrc *src = GST_TCP_MIX_SRC (GST_PAD_PARENT (pad));
gssize avail, receivedBytes;
GstMapInfo map;
GError *err = NULL;
/* if we have a client, wait for read */
GST_LOG_OBJECT (pad, "asked for a buffer");
if (!pad->client) {
if (src->mode == MODE_LOOP)
goto loop_read;
else
goto no_client;
}
/* read the buffer header */
read_available_bytes:
avail = g_socket_get_available_bytes (pad->client);
if (avail < 0) {
goto socket_get_available_bytes_error;
} else if (avail == 0) {
GIOCondition condition;
if (!g_socket_condition_wait (pad->client,
G_IO_IN | G_IO_PRI | G_IO_ERR | G_IO_HUP, pad->cancellable, &err))
goto socket_condition_wait_error;
condition = g_socket_condition_check (pad->client,
G_IO_IN | G_IO_PRI | G_IO_ERR | G_IO_HUP);
if ((condition & G_IO_ERR))
goto socket_condition_error;
else if ((condition & G_IO_HUP))
goto socket_condition_hup;
avail = g_socket_get_available_bytes (pad->client);
if (avail < 0)
goto socket_get_available_bytes_error;
}
if (0 < avail) {
gsize readBytes = MIN (avail, MAX_READ_SIZE);
*outbuf = gst_buffer_new_and_alloc (readBytes);
gst_buffer_map (*outbuf, &map, GST_MAP_READWRITE);
receivedBytes = g_socket_receive (pad->client, (gchar *) map.data,
readBytes, pad->cancellable, &err);
} else {
/* Connection closed */
receivedBytes = 0;
*outbuf = NULL;
}
if (receivedBytes == 0)
goto socket_connection_closed;
else if (receivedBytes < 0)
goto socket_receive_error;
gst_buffer_unmap (*outbuf, &map);
gst_buffer_resize (*outbuf, 0, receivedBytes);
#if 0
GST_LOG_OBJECT (pad,
"Returning buffer from _get of size %" G_GSIZE_FORMAT
", ts %" GST_TIME_FORMAT ", dur %" GST_TIME_FORMAT
", offset %" G_GINT64_FORMAT ", offset_end %" G_GINT64_FORMAT,
gst_buffer_get_size (*outbuf),
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (*outbuf)),
GST_TIME_ARGS (GST_BUFFER_DURATION (*outbuf)),
GST_BUFFER_OFFSET (*outbuf), GST_BUFFER_OFFSET_END (*outbuf));
#endif
g_clear_error (&err);
return GST_FLOW_OK;
/* Handling Errors */
no_client:
{
GST_ELEMENT_ERROR (pad, RESOURCE, READ, (NULL),
("No client socket (%s)", GST_PAD_NAME (pad)));
if (src->mode == MODE_LOOP)
goto loop_read;
return GST_FLOW_ERROR;
}
socket_get_available_bytes_error:
{
GST_ELEMENT_ERROR (pad, RESOURCE, READ, (NULL),
("Failed to get available bytes from socket"));
gst_tcp_mix_src_pad_reset (pad);
if (src->mode == MODE_LOOP)
goto loop_read;
return GST_FLOW_ERROR;
}
socket_condition_wait_error:
{
GST_ELEMENT_ERROR (pad, RESOURCE, READ, (NULL),
("Select failed: %s", err->message));
g_clear_error (&err);
gst_tcp_mix_src_pad_reset (pad);
if (src->mode == MODE_LOOP)
goto loop_read;
return GST_FLOW_ERROR;
}
socket_condition_error:
{
GST_ELEMENT_ERROR (pad, RESOURCE, READ, (NULL), ("Socket in error state"));
*outbuf = NULL;
gst_tcp_mix_src_pad_reset (pad);
if (src->mode == MODE_LOOP)
goto loop_read;
return GST_FLOW_ERROR;
}
socket_condition_hup:
{
GST_DEBUG_OBJECT (pad, "Connection closed");
*outbuf = NULL;
gst_tcp_mix_src_pad_reset (pad);
if (src->mode == MODE_LOOP)
goto loop_read;
return GST_FLOW_EOS;
}
socket_connection_closed:
{
GST_DEBUG_OBJECT (pad, "Connection closed");
if (*outbuf) {
gst_buffer_unmap (*outbuf, &map);
gst_buffer_unref (*outbuf);
}
*outbuf = NULL;
gst_tcp_mix_src_pad_reset (pad);
if (src->mode == MODE_LOOP)
goto loop_read;
return GST_FLOW_EOS;
}
socket_receive_error:
{
gst_buffer_unmap (*outbuf, &map);
gst_buffer_unref (*outbuf);
*outbuf = NULL;
if (g_error_matches (err, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
GST_DEBUG_OBJECT (pad, "Cancelled reading from socket");
if (src->mode == MODE_LOOP)
goto loop_read;
return GST_FLOW_FLUSHING;
} else {
GST_ELEMENT_ERROR (pad, RESOURCE, READ, (NULL),
("Failed to read from socket: %s", err->message));
if (src->mode == MODE_LOOP)
goto loop_read;
return GST_FLOW_ERROR;
}
}
loop_read:
{
#if 0
GstEvent *event = gst_event_new_flush_start ();
if (!gst_pad_push_event (pad, event)) {
GST_ERROR_OBJECT (src, "Failed to flush data on %s.%s",
GST_ELEMENT_NAME (src), GST_PAD_NAME (pad));
}
#endif
#if 0
GST_DEBUG_OBJECT (pad, "Looping");
#endif
if (src->fill == FILL_NONE) {
gst_tcp_mix_src_pad_wait_for_client (pad);
goto read_available_bytes;
}
enum
{ buffer_size = 1024 };
*outbuf = gst_buffer_new_and_alloc (buffer_size);
switch (src->fill) {
case FILL_ZERO:
break;
case FILL_RAND:
{
guchar *p;
gst_buffer_map (*outbuf, &map, GST_MAP_READWRITE);
for (p = map.data; p < map.data + buffer_size; p += 4) {
*((int *) p) = rand ();
}
} break;
}
return GST_FLOW_OK;
}
}
/*!
* Read a QMP message.
*
* \param socket \c GSocket to use.
* \param expected_count Number of messages to try to receive.
* \param[out] msgs List of received messages (which are of
* type \c GString).
* \param[out] count Number of messages saved in \p msgs.
* \return \c true on success, else \c false.
*/
static gboolean
clr_oci_qmp_msg_recv (GSocket *socket,
gsize expected_count,
GSList **msgs,
gsize *count)
{
gboolean ret = false;
gchar buffer[CLR_OCI_NET_BUF_SIZE];
gsize total = 0;
gssize bytes;
gssize msg_len;
GError *error = NULL;
GString *msg = NULL;
GString *received = NULL;
gchar *p;
g_assert (socket);
g_assert (expected_count);
g_assert (msgs);
g_assert (count);
g_debug ("client expects %lu message%s",
expected_count,
expected_count == 1 ? "" : "s");
do {
/* reset */
memset (buffer, '\0', CLR_OCI_NET_BUF_SIZE);
/* read a chunk */
bytes = g_socket_receive (socket, buffer, CLR_OCI_NET_BUF_SIZE,
NULL, &error);
if (bytes <= 0) {
g_critical ("client failed to receive: %s",
error->message);
g_error_free (error);
goto out;
}
/* save the chunk */
if (! received) {
received = g_string_new_len (buffer, bytes);
} else {
g_string_append_len (received, buffer, bytes);
}
total += (gsize)bytes;
while (true) {
if (! received->len) {
/* All the data read so far has been consumed */
break;
}
/* Check for end of message marker to determine if a
* complete message has been received yet.
*/
p = g_strstr_len (received->str, (gssize)total,
CLR_OCI_MSG_SEPARATOR);
if (! p) {
/* No complete message to operate on */
break;
}
/* We now have (*atleast* !!) one complete message to handle */
/* Calculate the length of the message */
msg_len = p - received->str;
/* Save the message */
msg = g_string_new_len (received->str, msg_len);
/* Add the the complete message to the list */
*msgs = g_slist_append (*msgs, msg);
(*count)++;
g_debug ("client read message %lu '%s' (len=%lu)",
(unsigned long int)*count,
msg->str,
msg->len);
/* Remove the handled data
* (including the message separator).
*/
g_string_erase (received, 0,
(gssize)
((gsize)msg_len + sizeof (CLR_OCI_MSG_SEPARATOR)-1));
/* Get ready to potentially receive a new
* message (caller is responsible for freeing the list).
*/
msg = NULL;
}
if (*count == expected_count) {
g_debug ("found expected number of messages (%lu)",
(unsigned long int)expected_count);
break;
}
} while (true);
/* All complete messages should have been added to the list */
g_assert (! msg);
/* All received data should have been handled */
g_assert (! received->len);
/* clean up */
g_string_free (received, true);
g_debug ("client received %lu message%s "
"(expected %lu) in %lu bytes",
(unsigned long int)*count,
*count == 1 ? "" : "s",
(unsigned long int)expected_count,
(unsigned long int)total);
ret = *count == expected_count;
out:
return ret;
}
gboolean
_write_register (ArvGvDeviceIOData *io_data, guint32 address, guint32 value, GError **error)
{
ArvGvcpPacket *packet;
size_t packet_size;
int count;
unsigned int n_retries = 0;
gboolean success = FALSE;
g_mutex_lock (io_data->mutex);
packet = arv_gvcp_packet_new_write_register_cmd (address, value, io_data->packet_id, &packet_size);
do {
io_data->packet_id = arv_gvcp_next_packet_id (io_data->packet_id);
arv_gvcp_packet_set_packet_id (packet, io_data->packet_id);
arv_gvcp_packet_debug (packet, ARV_DEBUG_LEVEL_LOG);
g_socket_send_to (io_data->socket, io_data->device_address, (const char *) packet, packet_size,
NULL, NULL);
if (g_poll (&io_data->poll_in_event, 1, io_data->gvcp_timeout_ms) > 0) {
count = g_socket_receive (io_data->socket, io_data->buffer,
ARV_GV_DEVICE_BUFFER_SIZE, NULL, NULL);
if (count > 0) {
ArvGvcpPacket *ack_packet = io_data->buffer;
ArvGvcpPacketType packet_type;
ArvGvcpCommand command;
guint16 packet_id;
arv_gvcp_packet_debug (ack_packet, ARV_DEBUG_LEVEL_LOG);
packet_type = arv_gvcp_packet_get_packet_type (ack_packet);
command = arv_gvcp_packet_get_command (ack_packet);
packet_id = arv_gvcp_packet_get_packet_id (ack_packet);
arv_log_gvcp ("%d, %d, %d", packet_type, command, packet_id);
if (packet_type == ARV_GVCP_PACKET_TYPE_ACK &&
command == ARV_GVCP_COMMAND_WRITE_REGISTER_ACK &&
packet_id == io_data->packet_id)
success = TRUE;
else
arv_gvcp_packet_debug (ack_packet, ARV_DEBUG_LEVEL_WARNING);
}
}
n_retries++;
} while (!success && n_retries < io_data->gvcp_n_retries);
arv_gvcp_packet_free (packet);
g_mutex_unlock (io_data->mutex);
if (!success) {
if (error != NULL && *error == NULL)
*error = g_error_new (ARV_DEVICE_ERROR, ARV_DEVICE_STATUS_TIMEOUT,
"[ArvDevice::write_register] Timeout");
}
return success;
}
static void
arv_gv_interface_receive_hello_packet (ArvGvInterface *gv_interface)
{
GPollFD *poll_fd;
GSList *iter;
char buffer[ARV_GV_INTERFACE_SOCKET_BUFFER_SIZE] __attribute__((may_alias));
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);
}
/**
* facq_net_receive:
* @skt: A connected #GSocket object.
* @buf: A pointer to a free memory area.
* @size: The size of the memory area pointed by @buf.
* @retry: The number of times to retry receiving data until @buf is full, or 0.
* if 0 the function will use an automatic number of retries, and won't return
* until size bytes are read.
* @err: A #GError, it will be set in case of error if not %NULL.
*
* Receives @size bytes, in the memory area pointed by @buf, from the connect
* socket @skt, using at most @retry retries.
*
* Returns: The number of bytes received if successful, 0 if disconnected, -1 in case of error,
* -2 in case of timeout, -3 if wrong parameters are passed to the function.
*/
gssize facq_net_receive(GSocket *skt,gchar *buf,gsize size,guint retry,GError **err)
{
guint retries = 0;
gsize to_read = 0, remaining = 0;
gssize ret = 0, total = 0;
GError *local_err = NULL;
if(!check_values(skt,buf,size)) {
if(err != NULL)
g_set_error_literal(err,G_IO_ERROR,
G_IO_ERROR_FAILED,"Can't receive any data");
return -3;
}
if(retry == 0)
retry = G_MAXUINT;
to_read = 0;
remaining = size;
for(retries = 0; retries < retry && total < size; retries++) {
#if ENABLE_DEBUG
facq_log_write_v(FACQ_LOG_MSG_TYPE_DEBUG,"Receiving data retry=%u",retries);
#endif
ret = g_socket_receive(skt,&buf[to_read],remaining,NULL,&local_err);
#if ENABLE_DEBUG
facq_log_write_v(FACQ_LOG_MSG_TYPE_DEBUG,
"g_socket_receive ret=%"G_GSSIZE_FORMAT,
ret);
#endif
switch(ret) {
case 0:
facq_log_write_v(FACQ_LOG_MSG_TYPE_INFO,
"Disconnected");
return 0;
break;
case -1:
if(local_err) {
facq_log_write_v(FACQ_LOG_MSG_TYPE_ERROR,
"%s",local_err->message);
if(err != NULL)
g_propagate_error(err,local_err);
return -1;
}
else {
if(err != NULL)
g_set_error_literal(err,G_IO_ERROR,
G_IO_ERROR_FAILED,"Error receiving data");
facq_log_write_v(FACQ_LOG_MSG_TYPE_ERROR,
"Unknown error receiving data");
return -1;
}
break;
default:
total += ret;
to_read += ret;
remaining = size - total;
if(total == size)
break;
}
}
if(total != size) {
if(err != NULL)
g_set_error_literal(err,G_IO_ERROR,
G_IO_ERROR_TIMED_OUT,"Operation timed out");
return -2;
}
return total;
}
static gboolean
_read_memory (ArvGvDeviceIOData *io_data, guint32 address, guint32 size, void *buffer, GError **error)
{
ArvGvcpPacket *packet;
size_t packet_size;
size_t answer_size;
int count;
unsigned int n_retries = 0;
gboolean success = FALSE;
answer_size = arv_gvcp_packet_get_read_memory_ack_size (size);
g_return_val_if_fail (answer_size <= ARV_GV_DEVICE_BUFFER_SIZE, FALSE);
g_mutex_lock (io_data->mutex);
packet = arv_gvcp_packet_new_read_memory_cmd (address,
((size + sizeof (guint32) - 1)
/ sizeof (guint32)) * sizeof (guint32),
0, &packet_size);
do {
io_data->packet_id = arv_gvcp_next_packet_id (io_data->packet_id);
arv_gvcp_packet_set_packet_id (packet, io_data->packet_id);
arv_gvcp_packet_debug (packet, ARV_DEBUG_LEVEL_LOG);
g_socket_send_to (io_data->socket, io_data->device_address,
(const char *) packet, packet_size,
NULL, NULL);
if (g_poll (&io_data->poll_in_event, 1, io_data->gvcp_timeout_ms) > 0) {
count = g_socket_receive (io_data->socket, io_data->buffer,
ARV_GV_DEVICE_BUFFER_SIZE, NULL, NULL);
if (count >= answer_size) {
ArvGvcpPacket *ack_packet = io_data->buffer;
ArvGvcpPacketType packet_type;
ArvGvcpCommand command;
guint16 packet_id;
arv_gvcp_packet_debug (ack_packet, ARV_DEBUG_LEVEL_LOG);
packet_type = arv_gvcp_packet_get_packet_type (ack_packet);
command = arv_gvcp_packet_get_command (ack_packet);
packet_id = arv_gvcp_packet_get_packet_id (ack_packet);
if (packet_type == ARV_GVCP_PACKET_TYPE_ACK &&
command == ARV_GVCP_COMMAND_READ_MEMORY_ACK &&
packet_id == io_data->packet_id) {
memcpy (buffer, arv_gvcp_packet_get_read_memory_ack_data (ack_packet), size);
success = TRUE;
} else
arv_gvcp_packet_debug (ack_packet, ARV_DEBUG_LEVEL_WARNING);
}
}
n_retries++;
} while (!success && n_retries < io_data->gvcp_n_retries);
arv_gvcp_packet_free (packet);
g_mutex_unlock (io_data->mutex);
if (!success) {
if (error != NULL && *error == NULL)
*error = g_error_new (ARV_DEVICE_ERROR, ARV_DEVICE_STATUS_TIMEOUT,
"[ArvDevice::read_memory] Timeout");
}
return success;
}
gboolean moloch_http_read_cb(gint UNUSED(fd), GIOCondition cond, gpointer data) {
MolochConn_t *conn = data;
char buffer[0xffff];
int len;
GError *gerror = 0;
len = g_socket_receive(conn->conn, buffer, sizeof(buffer)-1, NULL, &gerror);
if (gerror || cond & (G_IO_HUP | G_IO_ERR) || len <= 0) {
if (gerror) {
LOG("ERROR: %p:%p Receive Error: %s", (void*)conn, conn->request, gerror->message);
g_error_free(gerror);
} else if (cond & (G_IO_HUP | G_IO_ERR))
LOG("ERROR: %p:%p Lost connection to %s", (void*)conn, conn->request, conn->name);
else if (len <= 0)
LOG("ERROR: %p:%p len: %d cond: %x", (void*)conn, conn->request, len, cond);
else
LOG("ERROR HMM: %p:%p len: %d cond: %x", (void*)conn, conn->request, len, cond);
if (conn->request) {
// Must save, free, then call function because of recursive sync GETs
MolochResponse_cb func = conn->request->func;
gpointer uw = conn->request->uw;
MOLOCH_TYPE_FREE(MolochRequest_t, conn->request);
if (func) {
func(0, 0, uw);
}
}
g_object_unref (conn->conn);
conn->conn = 0;
if (conn != conn->server->syncConn && conn->request) {
DLL_PUSH_TAIL(e_, &conn->server->connQ, conn);
}
conn->request = 0;
return FALSE;
}
http_parser_execute(&conn->parser, &parserSettings, buffer, len);
if (conn->hp_complete) {
gettimeofday(&conn->endTime, NULL);
if (config.logESRequests)
LOG("%s %ldms %ldms %ldms",
conn->line,
(conn->sendTime.tv_sec - conn->startTime.tv_sec)*1000 + (conn->sendTime.tv_usec - conn->startTime.tv_usec)/1000,
(conn->sentTime.tv_sec - conn->startTime.tv_sec)*1000 + (conn->sentTime.tv_usec - conn->startTime.tv_usec)/1000,
(conn->endTime.tv_sec - conn->startTime.tv_sec)*1000 + (conn->endTime.tv_usec - conn->startTime.tv_usec)/1000
);
conn->hp_data[conn->hp_len] = 0;
/* Must save, free, then call function because of recursive sync GETs */
MolochResponse_cb func = conn->request->func;
gpointer uw = conn->request->uw;
MOLOCH_TYPE_FREE(MolochRequest_t, conn->request);
conn->request = 0;
if (func) {
func((unsigned char*)conn->hp_data, conn->hp_len, uw);
}
if (conn == conn->server->syncConn)
return TRUE;
int q;
for (q = 0; q < 2; q++) {
DLL_POP_HEAD(r_, &conn->server->requestQ[q], conn->request);
if (conn->request) {
if (!moloch_http_process_send(conn, 0)) {
DLL_PUSH_HEAD(r_, &conn->server->requestQ[q], conn->request);
conn->request = 0;
DLL_PUSH_TAIL(e_, &conn->server->connQ, conn);
}
return TRUE;
}
}
DLL_PUSH_TAIL(e_, &conn->server->connQ, conn);
}
return TRUE;
}
static gboolean
nl_connection_handler (GSocket *socket, GIOCondition condition, gpointer user_data)
{
GError *error = NULL;
gsize len;
gboolean ret = TRUE;
static gboolean first_time = TRUE;
char buff[BUFF_SIZE];
size_t recv_len;
struct sockaddr_nl from_nla;
socklen_t from_nla_len;
struct nlmsghdr *nlh;
struct sockaddr_nl kern_nla;
struct cn_msg *cn_hdr;
if (first_time) {
first_time = FALSE;
g_socket_set_timeout(socket, 0);
}
kern_nla.nl_family = AF_NETLINK;
kern_nla.nl_groups = CN_IDX_PROC;
kern_nla.nl_pid = 1;
kern_nla.nl_pad = 0;
memset(buff, 0, sizeof(buff));
from_nla_len = sizeof(from_nla);
memcpy(&from_nla, &kern_nla, sizeof(from_nla));
/* the helper process exited */
// this should not happen to netlink
if ((condition & G_IO_HUP) > 0) {
g_warning ("netlink: socket was disconnected");
ret = FALSE;
goto out;
}
/* there is data */
if ((condition & G_IO_IN) > 0) {
len = g_socket_receive (socket, buff, sizeof(buff), NULL, &error);
if (error != NULL) {
g_warning ("netlink: failed to get data: %s", error->message);
if (error->code == G_IO_ERROR_TIMED_OUT) {
g_warning("netlink: realtime monitoring disabled. Compile kernel with PROC_EVENTS enabled.");
ret = FALSE;
}
g_error_free (error);
goto out;
}
if (len == ENOBUFS) {
g_warning("netlink: NETLINK BUFFER FULL, MESSAGE DROPPED!");
return 0;
}
if (len == 0)
goto out;
nlh = (struct nlmsghdr *)buff;
while (NLMSG_OK(nlh, len)) {
cn_hdr = NLMSG_DATA(nlh);
if (nlh->nlmsg_type == NLMSG_NOOP) {
nlh = NLMSG_NEXT(nlh, recv_len);
continue;
}
if ((nlh->nlmsg_type == NLMSG_ERROR) ||
(nlh->nlmsg_type == NLMSG_OVERRUN))
break;
if (nl_handle_msg(cn_hdr) < 0)
return 1;
if (nlh->nlmsg_type == NLMSG_DONE)
break;
nlh = NLMSG_NEXT(nlh, recv_len);
}
}
out:
if (!ret)
g_socket_close(socket, NULL);
return ret;
}
static void *
arv_gv_stream_thread (void *data)
{
ArvGvStreamThreadData *thread_data = data;
ArvGvStreamFrameData *frame;
ArvGvspPacket *packet;
guint32 packet_id;
guint32 frame_id;
GTimeVal current_time;
guint64 time_us;
GPollFD poll_fd;
size_t read_count;
int timeout_ms;
int n_events;
int i;
gboolean first_packet = TRUE;
thread_data->frames = NULL;
arv_debug_stream_thread ("[GvStream::stream_thread] Packet timeout = %g ms",
thread_data->packet_timeout_us / 1000.0);
arv_debug_stream_thread ("[GvStream::stream_thread] Frame retention = %g ms",
thread_data->frame_retention_us / 1000.0);
if (thread_data->callback != NULL)
thread_data->callback (thread_data->user_data, ARV_STREAM_CALLBACK_TYPE_INIT, NULL);
poll_fd.fd = g_socket_get_fd (thread_data->socket);
poll_fd.events = G_IO_IN;
poll_fd.revents = 0;
packet = g_malloc0 (ARV_GV_STREAM_INCOMING_BUFFER_SIZE);
do {
if (thread_data->frames != NULL)
timeout_ms = thread_data->packet_timeout_us / 1000;
else
timeout_ms = ARV_GV_STREAM_POLL_TIMEOUT_US / 1000;
n_events = g_poll (&poll_fd, 1, timeout_ms);
g_get_current_time (¤t_time);
time_us = current_time.tv_sec * 1000000 + current_time.tv_usec;
if (n_events > 0) {
thread_data->n_received_packets++;
read_count = g_socket_receive (thread_data->socket, (char *) packet,
ARV_GV_STREAM_INCOMING_BUFFER_SIZE, NULL, NULL);
frame_id = arv_gvsp_packet_get_frame_id (packet);
packet_id = arv_gvsp_packet_get_packet_id (packet);
if (first_packet) {
thread_data->last_frame_id = frame_id - 1;
first_packet = FALSE;
}
frame = _find_frame_data (thread_data, frame_id, packet, packet_id, read_count, time_us);
if (frame != NULL) {
ArvGvspPacketType packet_type = arv_gvsp_packet_get_packet_type (packet);
if (packet_type != ARV_GVSP_PACKET_TYPE_OK &&
packet_type != ARV_GVSP_PACKET_TYPE_RESEND) {
arv_debug_stream_thread ("[GvStream::stream_thread]"
" Error packet at dt = %" G_GINT64_FORMAT ", packet id = %u"
" frame id = %u",
time_us - frame->first_packet_time_us,
packet_id, frame->frame_id);
arv_gvsp_packet_debug (packet, read_count, ARV_DEBUG_LEVEL_DEBUG);
frame->error_packet_received = TRUE;
thread_data->n_error_packets++;
} else {
/* Check for duplicated packets */
if (packet_id < frame->n_packets) {
if (frame->packet_data[packet_id].received)
thread_data->n_duplicated_packets++;
else
frame->packet_data[packet_id].received = TRUE;
}
/* Keep track of last packet of a continuous block starting from packet 0 */
for (i = frame->last_valid_packet + 1; i < frame->n_packets; i++)
if (!frame->packet_data[i].received)
break;
frame->last_valid_packet = i - 1;
switch (arv_gvsp_packet_get_content_type (packet)) {
case ARV_GVSP_CONTENT_TYPE_DATA_LEADER:
_process_data_leader (thread_data, frame, packet, packet_id);
break;
case ARV_GVSP_CONTENT_TYPE_DATA_BLOCK:
_process_data_block (thread_data, frame, packet, packet_id,
read_count);
break;
case ARV_GVSP_CONTENT_TYPE_DATA_TRAILER:
_process_data_trailer (thread_data, frame, packet, packet_id);
break;
default:
thread_data->n_ignored_packets++;
break;
}
_missing_packet_check (thread_data, frame, packet_id, time_us);
}
} else
thread_data->n_ignored_packets++;
} else
frame = NULL;
_check_frame_completion (thread_data, time_us, frame);
} while (!thread_data->cancel);
_flush_frames (thread_data);
if (thread_data->callback != NULL)
thread_data->callback (thread_data->user_data, ARV_STREAM_CALLBACK_TYPE_EXIT, NULL);
g_free (packet);
return NULL;
}
static GstFlowReturn
gst_tcp_server_src_create (GstPushSrc * psrc, GstBuffer ** outbuf)
{
GstTCPServerSrc *src;
GstFlowReturn ret = GST_FLOW_OK;
gssize rret, avail;
gsize read;
GError *err = NULL;
GstMapInfo map;
src = GST_TCP_SERVER_SRC (psrc);
if (!GST_OBJECT_FLAG_IS_SET (src, GST_TCP_SERVER_SRC_OPEN))
goto wrong_state;
if (!src->client_socket) {
/* wait on server socket for connections */
src->client_socket =
g_socket_accept (src->server_socket, src->cancellable, &err);
if (!src->client_socket)
goto accept_error;
/* now read from the socket. */
}
/* if we have a client, wait for read */
GST_LOG_OBJECT (src, "asked for a buffer");
/* read the buffer header */
avail = g_socket_get_available_bytes (src->client_socket);
if (avail < 0) {
goto get_available_error;
} else if (avail == 0) {
GIOCondition condition;
if (!g_socket_condition_wait (src->client_socket,
G_IO_IN | G_IO_PRI | G_IO_ERR | G_IO_HUP, src->cancellable, &err))
goto select_error;
condition =
g_socket_condition_check (src->client_socket,
G_IO_IN | G_IO_PRI | G_IO_ERR | G_IO_HUP);
if ((condition & G_IO_ERR)) {
GST_ELEMENT_ERROR (src, RESOURCE, READ, (NULL),
("Socket in error state"));
*outbuf = NULL;
ret = GST_FLOW_ERROR;
goto done;
} else if ((condition & G_IO_HUP)) {
GST_DEBUG_OBJECT (src, "Connection closed");
*outbuf = NULL;
ret = GST_FLOW_EOS;
goto done;
}
avail = g_socket_get_available_bytes (src->client_socket);
if (avail < 0)
goto get_available_error;
}
if (avail > 0) {
read = MIN (avail, MAX_READ_SIZE);
*outbuf = gst_buffer_new_and_alloc (read);
gst_buffer_map (*outbuf, &map, GST_MAP_READWRITE);
rret =
g_socket_receive (src->client_socket, (gchar *) map.data, read,
src->cancellable, &err);
} else {
/* Connection closed */
rret = 0;
*outbuf = NULL;
read = 0;
}
if (rret == 0) {
GST_DEBUG_OBJECT (src, "Connection closed");
ret = GST_FLOW_EOS;
if (*outbuf) {
gst_buffer_unmap (*outbuf, &map);
gst_buffer_unref (*outbuf);
}
*outbuf = NULL;
} else if (rret < 0) {
if (g_error_matches (err, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
ret = GST_FLOW_FLUSHING;
GST_DEBUG_OBJECT (src, "Cancelled reading from socket");
} else {
ret = GST_FLOW_ERROR;
GST_ELEMENT_ERROR (src, RESOURCE, READ, (NULL),
("Failed to read from socket: %s", err->message));
}
gst_buffer_unmap (*outbuf, &map);
gst_buffer_unref (*outbuf);
*outbuf = NULL;
} else {
ret = GST_FLOW_OK;
gst_buffer_unmap (*outbuf, &map);
gst_buffer_resize (*outbuf, 0, rret);
GST_LOG_OBJECT (src,
"Returning buffer from _get of size %" G_GSIZE_FORMAT ", ts %"
GST_TIME_FORMAT ", dur %" GST_TIME_FORMAT
", offset %" G_GINT64_FORMAT ", offset_end %" G_GINT64_FORMAT,
gst_buffer_get_size (*outbuf),
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (*outbuf)),
GST_TIME_ARGS (GST_BUFFER_DURATION (*outbuf)),
GST_BUFFER_OFFSET (*outbuf), GST_BUFFER_OFFSET_END (*outbuf));
}
g_clear_error (&err);
done:
return ret;
wrong_state:
{
GST_DEBUG_OBJECT (src, "connection to closed, cannot read data");
return GST_FLOW_FLUSHING;
}
accept_error:
{
if (g_error_matches (err, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
GST_DEBUG_OBJECT (src, "Cancelled accepting of client");
} else {
GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL),
("Failed to accept client: %s", err->message));
}
g_clear_error (&err);
return GST_FLOW_ERROR;
}
select_error:
{
GST_ELEMENT_ERROR (src, RESOURCE, READ, (NULL),
("Select failed: %s", err->message));
g_clear_error (&err);
return GST_FLOW_ERROR;
}
get_available_error:
{
GST_ELEMENT_ERROR (src, RESOURCE, READ, (NULL),
("Failed to get available bytes from socket"));
return GST_FLOW_ERROR;
}
}
/* Process the raw netlink message and dispatch to helper functions
* accordingly */
static void
receive_netlink_message (GUPnPLinuxContextManager *self, GError **error)
{
static char buf[4096];
static const int bufsize = 4096;
gssize len;
GError *inner_error = NULL;
struct nlmsghdr *header = (struct nlmsghdr *) buf;
struct ifinfomsg *ifi;
struct ifaddrmsg *ifa;
len = g_socket_receive (self->priv->netlink_socket,
buf,
bufsize,
NULL,
&inner_error);
if (len == -1) {
if (inner_error->code != G_IO_ERROR_WOULD_BLOCK)
g_warning ("Error receiving netlink message: %s",
inner_error->message);
g_propagate_error (error, inner_error);
return;
}
for (;NLMSG_IS_VALID (header, len); header = NLMSG_NEXT (header,len)) {
switch (header->nlmsg_type) {
/* RTM_NEWADDR and RTM_DELADDR are sent on real address
* changes.
* RTM_NEWLINK is sent on varous occations:
* - Creation of a new device
* - Device goes up/down
* - Wireless status changes
* RTM_DELLINK is sent only if device is removed, like
* openvpn --rmtun /dev/tun0, NOT on ifconfig down. */
case RTM_NEWADDR:
{
char *label = NULL;
ifa = NLMSG_DATA (header);
extract_info (header, &label);
create_context (self, label, ifa);
g_free (label);
}
break;
case RTM_DELADDR:
{
char *label = NULL;
ifa = NLMSG_DATA (header);
extract_info (header, &label);
remove_context (self, label, ifa);
g_free (label);
}
break;
case RTM_NEWLINK:
ifi = NLMSG_DATA (header);
/* Check if wireless is up for chit-chat */
if (is_wireless_status_message (header))
continue;
handle_device_status_change (self, ifi);
break;
case RTM_DELLINK:
ifi = NLMSG_DATA (header);
remove_device (self, ifi);
break;
case NLMSG_ERROR:
break;
default:
break;
}
}
}
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);
}
int
main (int argc,
char *argv[])
{
GSocket *socket, *new_socket, *recv_socket;
GSocketAddress *src_address;
GSocketAddress *address;
GSocketType socket_type;
GError *error = NULL;
GOptionContext *context;
GCancellable *cancellable;
g_thread_init (NULL);
g_type_init ();
context = g_option_context_new (" - Test GSocket server stuff");
g_option_context_add_main_entries (context, cmd_entries, NULL);
if (!g_option_context_parse (context, &argc, &argv, &error))
{
g_printerr ("%s: %s\n", argv[0], error->message);
return 1;
}
if (cancel_timeout)
{
cancellable = g_cancellable_new ();
g_thread_create (cancel_thread, cancellable, FALSE, NULL);
}
else
{
cancellable = NULL;
}
loop = g_main_loop_new (NULL, FALSE);
if (use_udp)
socket_type = G_SOCKET_TYPE_DATAGRAM;
else
socket_type = G_SOCKET_TYPE_STREAM;
socket = g_socket_new (G_SOCKET_FAMILY_IPV4, socket_type, 0, &error);
if (socket == NULL)
{
g_printerr ("%s: %s\n", argv[0], error->message);
return 1;
}
if (non_blocking)
g_socket_set_blocking (socket, FALSE);
src_address = g_inet_socket_address_new (g_inet_address_new_any (G_SOCKET_FAMILY_IPV4), port);
if (!g_socket_bind (socket, src_address, !dont_reuse_address, &error))
{
g_printerr ("Can't bind socket: %s\n", error->message);
return 1;
}
if (!use_udp)
{
if (!g_socket_listen (socket, &error))
{
g_printerr ("Can't listen on socket: %s\n", error->message);
return 1;
}
g_print ("listening on port %d...\n", port);
ensure_condition (socket, "accept", cancellable, G_IO_IN);
new_socket = g_socket_accept (socket, &error);
if (!new_socket)
{
g_printerr ("Error accepting socket: %s\n",
error->message);
return 1;
}
if (non_blocking)
g_socket_set_blocking (new_socket, FALSE);
address = g_socket_get_remote_address (new_socket, &error);
if (!address)
{
g_printerr ("Error getting remote address: %s\n",
error->message);
return 1;
}
g_print ("got a new connection from %s (blocking: %d)\n",
socket_address_to_string (address),
g_socket_get_blocking (new_socket));
recv_socket = new_socket;
}
else
{
recv_socket = socket;
new_socket = NULL;
}
while (TRUE)
{
gchar buffer[4096] = { };
gssize size;
gsize to_send;
ensure_condition (recv_socket, "receive", cancellable, G_IO_IN);
if (use_udp)
size = g_socket_receive_from (recv_socket, &address,
buffer, sizeof buffer, &error);
else
size = g_socket_receive (recv_socket, buffer, sizeof buffer, &error);
if (size < 0)
{
g_printerr ("Error receiving from socket: %s\n",
error->message);
return 1;
}
if (size == 0)
break;
g_print ("received %" G_GSSIZE_FORMAT " bytes of data", size);
if (use_udp)
g_print (" from %s", socket_address_to_string (address));
g_print ("\n");
if (verbose)
g_print ("-------------------------\n"
"%.*s\n"
"-------------------------\n",
(int)size, buffer);
to_send = size;
while (to_send > 0)
{
ensure_condition (recv_socket, "send", cancellable, G_IO_OUT);
if (use_udp)
size = g_socket_send_to (recv_socket, address,
buffer, to_send, &error);
else
size = g_socket_send (recv_socket, buffer, to_send, &error);
if (size < 0)
{
if (g_error_matches (error,
G_IO_ERROR,
G_IO_ERROR_WOULD_BLOCK))
{
g_print ("socket send would block, handling\n");
g_error_free (error);
error = NULL;
continue;
}
else
{
g_printerr ("Error sending to socket: %s\n",
error->message);
return 1;
}
}
g_print ("sent %" G_GSSIZE_FORMAT " bytes of data\n", size);
if (size == 0)
{
g_printerr ("Unexpected short write\n");
return 1;
}
to_send -= size;
}
}
g_print ("connection closed\n");
if (new_socket)
{
if (!g_socket_close (new_socket, &error))
{
g_printerr ("Error closing connection socket: %s\n",
error->message);
return 1;
}
g_object_unref (G_OBJECT (new_socket));
}
if (!g_socket_close (socket, &error))
{
g_printerr ("Error closing master socket: %s\n",
error->message);
return 1;
}
g_object_unref (G_OBJECT (socket));
return 0;
}
int
main (int argc,
char *argv[])
{
GSocket *socket;
GSocketAddress *src_address;
GSocketAddress *address;
GSocketType socket_type;
GSocketFamily socket_family;
GError *error = NULL;
GOptionContext *context;
GCancellable *cancellable;
GSocketAddressEnumerator *enumerator;
GSocketConnectable *connectable;
g_thread_init (NULL);
g_type_init ();
context = g_option_context_new (" <hostname>[:port] - Test GSocket client stuff");
g_option_context_add_main_entries (context, cmd_entries, NULL);
if (!g_option_context_parse (context, &argc, &argv, &error))
{
g_printerr ("%s: %s\n", argv[0], error->message);
return 1;
}
if (argc != 2)
{
g_printerr ("%s: %s\n", argv[0], "Need to specify hostname / unix socket name");
return 1;
}
if (cancel_timeout)
{
cancellable = g_cancellable_new ();
g_thread_create (cancel_thread, cancellable, FALSE, NULL);
}
else
{
cancellable = NULL;
}
loop = g_main_loop_new (NULL, FALSE);
if (use_udp)
socket_type = G_SOCKET_TYPE_DATAGRAM;
else
socket_type = G_SOCKET_TYPE_STREAM;
if (unix_socket)
socket_family = G_SOCKET_FAMILY_UNIX;
else
socket_family = G_SOCKET_FAMILY_IPV4;
socket = g_socket_new (socket_family, socket_type, 0, &error);
if (socket == NULL)
{
g_printerr ("%s: %s\n", argv[0], error->message);
return 1;
}
if (read_timeout)
g_socket_set_timeout (socket, read_timeout);
if (unix_socket)
{
GSocketAddress *addr;
addr = socket_address_from_string (argv[1]);
if (addr == NULL)
{
g_printerr ("%s: Could not parse '%s' as unix socket name\n", argv[0], argv[1]);
return 1;
}
connectable = G_SOCKET_CONNECTABLE (addr);
}
else
{
connectable = g_network_address_parse (argv[1], 7777, &error);
if (connectable == NULL)
{
g_printerr ("%s: %s\n", argv[0], error->message);
return 1;
}
}
enumerator = g_socket_connectable_enumerate (connectable);
while (TRUE)
{
address = g_socket_address_enumerator_next (enumerator, cancellable, &error);
if (address == NULL)
{
if (error == NULL)
g_printerr ("%s: No more addresses to try\n", argv[0]);
else
g_printerr ("%s: %s\n", argv[0], error->message);
return 1;
}
if (g_socket_connect (socket, address, cancellable, &error))
break;
g_printerr ("%s: Connection to %s failed: %s, trying next\n", argv[0], socket_address_to_string (address), error->message);
g_error_free (error);
error = NULL;
g_object_unref (address);
}
g_object_unref (enumerator);
g_object_unref (connectable);
g_print ("Connected to %s\n",
socket_address_to_string (address));
/* TODO: Test non-blocking connect */
if (non_blocking)
g_socket_set_blocking (socket, FALSE);
src_address = g_socket_get_local_address (socket, &error);
if (!src_address)
{
g_printerr ("Error getting local address: %s\n",
error->message);
return 1;
}
g_print ("local address: %s\n",
socket_address_to_string (src_address));
g_object_unref (src_address);
while (TRUE)
{
gchar buffer[4096];
gssize size;
gsize to_send;
if (fgets (buffer, sizeof buffer, stdin) == NULL)
break;
to_send = strlen (buffer);
while (to_send > 0)
{
ensure_condition (socket, "send", cancellable, G_IO_OUT);
if (use_udp)
size = g_socket_send_to (socket, address,
buffer, to_send,
cancellable, &error);
else
size = g_socket_send (socket, buffer, to_send,
cancellable, &error);
if (size < 0)
{
if (g_error_matches (error,
G_IO_ERROR,
G_IO_ERROR_WOULD_BLOCK))
{
g_print ("socket send would block, handling\n");
g_error_free (error);
error = NULL;
continue;
}
else
{
g_printerr ("Error sending to socket: %s\n",
error->message);
return 1;
}
}
g_print ("sent %" G_GSSIZE_FORMAT " bytes of data\n", size);
if (size == 0)
{
g_printerr ("Unexpected short write\n");
return 1;
}
to_send -= size;
}
ensure_condition (socket, "receive", cancellable, G_IO_IN);
if (use_udp)
size = g_socket_receive_from (socket, &src_address,
buffer, sizeof buffer,
cancellable, &error);
else
size = g_socket_receive (socket, buffer, sizeof buffer,
cancellable, &error);
if (size < 0)
{
g_printerr ("Error receiving from socket: %s\n",
error->message);
return 1;
}
if (size == 0)
break;
g_print ("received %" G_GSSIZE_FORMAT " bytes of data", size);
if (use_udp)
g_print (" from %s", socket_address_to_string (src_address));
g_print ("\n");
if (verbose)
g_print ("-------------------------\n"
"%.*s"
"-------------------------\n",
(int)size, buffer);
}
g_print ("closing socket\n");
if (!g_socket_close (socket, &error))
{
g_printerr ("Error closing master socket: %s\n",
error->message);
return 1;
}
g_object_unref (G_OBJECT (socket));
g_object_unref (G_OBJECT (address));
return 0;
}
