gint flags, res;
struct stat statbuf;
- GST_DEBUG_OBJECT (sink, "adding client on fd %d", fd);
+ GST_DEBUG_OBJECT (sink, "[fd %5d] adding client", fd);
/* create client datastructure */
client = g_new0 (GstTCPClient, 1);
if (clink != NULL) {
client->status = GST_CLIENT_STATUS_DUPLICATE;
g_mutex_unlock (sink->clientslock);
- GST_WARNING_OBJECT (sink, "duplicate client with fd %d found", fd);
+ GST_WARNING_OBJECT (sink, "[fd %5d] duplicate client found, refusing", fd);
g_signal_emit (G_OBJECT (sink),
gst_multifdsink_signals[SIGNAL_CLIENT_REMOVED], 0, fd, client->status);
g_free (client);
{
GList *clink;
- GST_DEBUG_OBJECT (sink, "removing client on fd %d", fd);
+ GST_DEBUG_OBJECT (sink, "[fd %5d] removing client", fd);
g_mutex_lock (sink->clientslock);
clink = g_hash_table_lookup (sink->fd_hash, &fd);
gst_multifdsink_remove_client_link (sink, clink);
SEND_COMMAND (sink, CONTROL_RESTART);
} else {
- GST_WARNING_OBJECT (sink, "no client with fd %d found!", fd);
+ GST_WARNING_OBJECT (sink, "[fd %5d] no client with this fd found!", fd);
}
g_mutex_unlock (sink->clientslock);
}
/* python doesn't like a NULL pointer yet */
if (result == NULL) {
- GST_WARNING_OBJECT (sink, "no client with fd %d found!", fd);
+ GST_WARNING_OBJECT (sink, "[fd %5d] no client with this found!", fd);
result = g_value_array_new (0);
}
/* FIXME: if we keep track of ip we can log it here and signal */
switch (client->status) {
case GST_CLIENT_STATUS_OK:
- GST_WARNING_OBJECT (sink, "removing client %p with fd %d for no reason",
- client, fd);
+ GST_WARNING_OBJECT (sink, "[fd %5d] removing client %p for no reason",
+ fd, client);
break;
case GST_CLIENT_STATUS_CLOSED:
- GST_DEBUG_OBJECT (sink, "removing client %p with fd %d because of close",
- client, fd);
+ GST_DEBUG_OBJECT (sink, "[fd %5d] removing client %p because of close",
+ fd, client);
break;
case GST_CLIENT_STATUS_REMOVED:
GST_DEBUG_OBJECT (sink,
- "removing client %p with fd %d because the app removed it", client,
- fd);
+ "[fd %5d] removing client %p because the app removed it", fd, client);
break;
case GST_CLIENT_STATUS_SLOW:
GST_INFO_OBJECT (sink,
- "removing client %p with fd %d because it was too slow", client, fd);
+ "[fd %5d] removing client %p because it was too slow", fd, client);
break;
case GST_CLIENT_STATUS_ERROR:
GST_WARNING_OBJECT (sink,
- "removing client %p with fd %d because of error", client, fd);
+ "[fd %5d] removing client %p because of error", fd, client);
break;
default:
GST_WARNING_OBJECT (sink,
- "removing client %p with fd %d with invalid reason", client, fd);
+ "[fd %5d] removing client %p with invalid reason", fd, client);
break;
}
if (!g_hash_table_remove (sink->fd_hash, &client->fd.fd)) {
GST_WARNING_OBJECT (sink,
- "error removing client %p with fd %d from hash", client, fd);
+ "[fd %5d] error removing client %p from hash", client->fd.fd, client);
}
sink->clients = g_list_delete_link (sink->clients, link);
fd = client->fd.fd;
if (ioctl (fd, FIONREAD, &avail) < 0) {
- GST_WARNING_OBJECT (sink, "ioctl failed for fd %d: %s",
- fd, g_strerror (errno));
+ GST_WARNING_OBJECT (sink, "[fd %5d] ioctl failed: %s (%d)",
+ fd, g_strerror (errno), errno);
client->status = GST_CLIENT_STATUS_ERROR;
ret = FALSE;
return ret;
}
- GST_DEBUG_OBJECT (sink, "select reports client read on fd %d of %d bytes",
+ GST_DEBUG_OBJECT (sink, "[fd %5d] select reports client read of %d bytes",
fd, avail);
ret = TRUE;
if (avail == 0) {
/* client sent close, so remove it */
- GST_DEBUG_OBJECT (sink, "client asked for close, removing on fd %d", fd);
+ GST_DEBUG_OBJECT (sink, "[fd %5d] client asked for close, removing", fd);
client->status = GST_CLIENT_STATUS_CLOSED;
ret = FALSE;
} else if (avail < 0) {
- GST_WARNING_OBJECT (sink, "avail < 0, removing on fd %d", fd);
+ GST_WARNING_OBJECT (sink, "[fd %5d] avail < 0, removing", fd);
client->status = GST_CLIENT_STATUS_ERROR;
ret = FALSE;
} else {
/* this is the maximum we can read */
gint to_read = MIN (avail, 512);
- GST_DEBUG_OBJECT (sink, "client on fd %d wants us to read %d bytes",
+ GST_DEBUG_OBJECT (sink, "[fd %5d] client wants us to read %d bytes",
fd, to_read);
nread = read (fd, dummy, to_read);
if (nread < -1) {
- GST_WARNING_OBJECT (sink, "could not read bytes from fd %d: %s",
- fd, g_strerror (errno));
+ GST_WARNING_OBJECT (sink, "[fd %5d] could not read %d bytes: %s (%d)",
+ fd, to_read, g_strerror (errno), errno);
client->status = GST_CLIENT_STATUS_ERROR;
ret = FALSE;
break;
} else if (nread == 0) {
- GST_WARNING_OBJECT (sink, "fd %d: gave 0 bytes in read, removing", fd);
+ GST_WARNING_OBJECT (sink, "[fd %5d] 0 bytes in read, removing", fd);
client->status = GST_CLIENT_STATUS_ERROR;
ret = FALSE;
break;
GST_BUFFER_DATA (buf) = data;
GST_BUFFER_SIZE (buf) = len;
- GST_LOG_OBJECT (sink, "Queueing data of length %d for fd %d",
- len, client->fd.fd);
+ GST_LOG_OBJECT (sink, "[fd %5d] queueing data of length %d",
+ client->fd.fd, len);
client->sending = g_slist_append (client->sending, buf);
gchar *string;
string = gst_caps_to_string (caps);
- GST_DEBUG_OBJECT (sink, "Queueing caps %s for fd %d through GDP", string,
- client->fd.fd);
+ GST_DEBUG_OBJECT (sink, "[fd %5d] Queueing caps %s through GDP",
+ client->fd.fd, string);
g_free (string);
if (!gst_dp_packet_from_caps (caps, 0, &length, &header, &payload)) {
if (!gst_dp_header_from_buffer (buffer, 0, &len, &header)) {
GST_DEBUG_OBJECT (sink,
- "could not create header, removing client on fd %d", client->fd.fd);
+ "[fd %5d] could not create header, removing client", client->fd.fd);
return FALSE;
}
gst_multifdsink_client_queue_data (sink, client, header, len);
}
- GST_LOG_OBJECT (sink, "Queueing buffer of length %d for fd %d",
- GST_BUFFER_SIZE (buffer), client->fd.fd);
+ GST_LOG_OBJECT (sink, "[fd %5d] queueing buffer of length %d",
+ client->fd.fd, GST_BUFFER_SIZE (buffer));
gst_buffer_ref (buffer);
client->sending = g_slist_append (client->sending, buffer);
/* if the buffer at the head of the queue is a sync point we can proceed,
* else we need to skip the buffer and wait for a new one */
GST_LOG_OBJECT (sink,
- "New client on fd %d, bufpos %d, waiting for keyframe", client->fd.fd,
+ "[fd %5d] new client, bufpos %d, waiting for keyframe", client->fd.fd,
client->bufpos);
/* the client is not yet alligned to a buffer */
/* get the buffer for the client */
buf = g_array_index (sink->bufqueue, GstBuffer *, i);
if (is_sync_frame (sink, buf)) {
- GST_LOG_OBJECT (sink, "New client on fd %d found sync",
+ GST_LOG_OBJECT (sink, "[fd %5d] new client, found sync",
client->fd.fd);
result = i;
goto done;
} else {
/* client is not on a buffer, need to skip this buffer and
* wait some more */
- GST_LOG_OBJECT (sink, "New client on fd %d skipping buffer",
+ GST_LOG_OBJECT (sink, "[fd %5d] new client, skipping buffer",
client->fd.fd);
client->bufpos--;
}
* the algorithm should behave as GST_SYNC_METHOD_WAIT */
gint i, len;
- GST_LOG_OBJECT (sink, "New client on fd %d, bufpos %d, bursting keyframe",
+ GST_LOG_OBJECT (sink, "[fd %5d] new client, bufpos %d, bursting keyframe",
client->fd.fd, client->bufpos);
/* take length of queued buffers */
*
* The strategy is as follows, for each client we maintain a queue of GstBuffers
* that contain the raw bytes we need to send to the client. In the case of the
- * GDP protocol, we create buffers out of the header bytes so that we can only focus
- * on sending buffers.
+ * GDP protocol, we create buffers out of the header bytes so that we can only
+ * focus on sending buffers.
*
- * We first check to see if we need to send caps (in GDP) and streamheaders. If so,
- * we queue them.
+ * We first check to see if we need to send caps (in GDP) and streamheaders.
+ * If so, we queue them.
*
- * Then we run into the main loop that tries to send as many buffers as possible. It
- * will first exhaust the client->sending queue and if the queue is empty, it will
- * pick a buffer from the global queue.
- *
- * Sending the Buffers from the client->sending queue is basically writing the bytes
- * to the socket and maintaining a count of the bytes that were sent. When the buffer
- * is completely sent, it is removed from the client->sending queue and we try to pick
- * a new buffer for sending.
+ * Then we run into the main loop that tries to send as many buffers as
+ * possible. It will first exhaust the client->sending queue and if the queue
+ * is empty, it will pick a buffer from the global queue.
*
- * When the sending returns a partial buffer we stop sending more data as the next send
- * operation could block.
+ * Sending the Buffers from the client->sending queue is basically writing
+ * the bytes to the socket and maintaining a count of the bytes that were
+ * sent. When the buffer is completely sent, it is removed from the
+ * client->sending queue and we try to pick a new buffer for sending.
+ *
+ * When the sending returns a partial buffer we stop sending more data as
+ * the next send operation could block.
*
* This functions returns FALSE if some error occured.
*/
/* grab buffer */
buf = g_array_index (sink->bufqueue, GstBuffer *, client->bufpos);
client->bufpos--;
- GST_LOG_OBJECT (sink, "client %p with fd %d at position %d",
- client, fd, client->bufpos);
+ GST_LOG_OBJECT (sink, "[fd %5d] client %p at position %d",
+ fd, client, client->bufpos);
/* queueing a buffer will ref it */
gst_multifdsink_client_queue_buffer (sink, client, buf);
if (errno == EAGAIN) {
/* nothing serious, resource was unavailable, try again later */
more = FALSE;
+ } else if (errno == ECONNRESET) {
+ GST_DEBUG_OBJECT (sink, "[fd %5d] connection reset by peer, removing",
+ fd);
+ client->status = GST_CLIENT_STATUS_CLOSED;
+ return FALSE;
} else {
GST_WARNING_OBJECT (sink,
- "could not write, removing client on fd %d: %s", fd,
- g_strerror (errno));
+ "[fd %5d] could not write, removing client: %s (%d)", fd,
+ g_strerror (errno), errno);
client->status = GST_CLIENT_STATUS_ERROR;
return FALSE;
}
gint newbufpos;
GST_WARNING_OBJECT (sink,
- "client %p with fd %d is lagging at %d, recover using policy %d", client,
- client->fd.fd, client->bufpos, sink->recover_policy);
+ "[fd %5d] client %p is lagging at %d, recover using policy %d",
+ client->fd.fd, client, client->bufpos, sink->recover_policy);
switch (sink->recover_policy) {
case GST_RECOVER_POLICY_NONE:
- /* do nothing, client will catch up or get kicked out when it reaches
+ /* do nothing, client will catch up or get kicked out when it reaches
* the hard max */
newbufpos = client->bufpos;
break;
next = g_list_next (clients);
client->bufpos++;
- GST_LOG_OBJECT (sink, "client %p with fd %d at position %d",
- client, client->fd.fd, client->bufpos);
+ GST_LOG_OBJECT (sink, "[fd %5d] client %p at position %d",
+ client->fd.fd, client, client->bufpos);
/* check soft max if needed, recover client */
if (sink->units_soft_max > 0 && client->bufpos >= sink->units_soft_max) {
gint newpos;
if (newpos != client->bufpos) {
client->bufpos = newpos;
client->discont = TRUE;
- GST_INFO_OBJECT (sink, "client %p with fd %d position reset to %d",
- client, client->fd.fd, client->bufpos);
+ GST_INFO_OBJECT (sink, "[fd %5d] client %p position reset to %d",
+ client->fd.fd, client, client->bufpos);
} else {
GST_INFO_OBJECT (sink,
- "client %p with fd %d not recovering position", client,
- client->fd.fd);
+ "[fd %5d] client %p not recovering position",
+ client->fd.fd, client);
}
}
/* check hard max and timeout, remove client */
(sink->timeout > 0
&& now - client->last_activity_time > sink->timeout)) {
/* remove client */
- GST_WARNING_OBJECT (sink, "client %p with fd %d is too slow, removing",
- client, client->fd.fd);
+ GST_WARNING_OBJECT (sink, "[fd %5d] client %p is too slow, removing",
+ client->fd.fd, client);
/* remove the client, the fd set will be cleared and the select thread will
* be signaled */
client->status = GST_CLIENT_STATUS_SLOW;
/* < 0 is an error, 0 just means a timeout happened, which is impossible */
if (result < 0) {
- GST_WARNING_OBJECT (sink, "wait failed: %s", g_strerror (errno));
+ GST_WARNING_OBJECT (sink, "wait failed: %s (%d)", g_strerror (errno),
+ errno);
if (errno == EBADF) {
/* ok, so one or more of the fds is invalid. We loop over them to find
* the ones that give an error to the F_GETFL fcntl. */
res = fcntl (fd, F_GETFL, &flags);
if (res == -1) {
- GST_WARNING_OBJECT (sink, "fnctl failed for %d, removing: %s",
- fd, g_strerror (errno));
+ GST_WARNING_OBJECT (sink, "fnctl failed for %d, removing: %s (%d)",
+ fd, g_strerror (errno), errno);
if (errno == EBADF) {
client->status = GST_CLIENT_STATUS_ERROR;
gst_multifdsink_remove_client_link (sink, clients);
} else {
/* this is quite bad... */
GST_ELEMENT_ERROR (sink, RESOURCE, READ, (NULL),
- ("select failed: %s", g_strerror (errno)));
+ ("select failed: %s (%d)", g_strerror (errno), errno));
return;
}
} else {
projects / platform / upstream / gst-plugins-base.git / commitdiff