mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-09-08 13:18:52 +00:00
Original commit message from CVS: * gst/tcp/gsttcp.c: * gst/tcp/gsttcpclientsink.c: * gst/tcp/gsttcpserversink.c: * gst/tcp/gsttcpserversrc.c: Add <string.h> includes for memset and FD_ZERO (fixes #323878; patch by: Benjamin Pineau).
583 lines
14 KiB
C
583 lines
14 KiB
C
/* GStreamer
|
|
* Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
|
|
* Copyright (C) <2004> Thomas Vander Stichele <thomas at apestaart dot org>
|
|
*
|
|
* gsttcp.c: TCP functions
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Library General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Library General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Library General Public
|
|
* License along with this library; if not, write to the
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
* Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/socket.h>
|
|
#include <netinet/in.h>
|
|
#include <arpa/inet.h>
|
|
#include <netdb.h>
|
|
#include <string.h> /* memset, in FD_ZERO macro */
|
|
#include <unistd.h>
|
|
#include <sys/ioctl.h>
|
|
|
|
#ifdef HAVE_FIONREAD_IN_SYS_FILIO
|
|
#include <sys/filio.h>
|
|
#endif
|
|
|
|
#include <glib.h>
|
|
#include <gst/gst.h>
|
|
#include <gst/gst-i18n-plugin.h>
|
|
#include <gst/dataprotocol/dataprotocol.h>
|
|
|
|
GST_DEBUG_CATEGORY_EXTERN (tcp_debug);
|
|
#define GST_CAT_DEFAULT tcp_debug
|
|
|
|
#ifndef MSG_NOSIGNAL
|
|
#define MSG_NOSIGNAL 0
|
|
#endif
|
|
|
|
/* resolve host to IP address, throwing errors if it fails */
|
|
/* host can already be an IP address */
|
|
/* returns a newly allocated gchar * with the dotted ip address,
|
|
or NULL, in which case it already fired an error. */
|
|
gchar *
|
|
gst_tcp_host_to_ip (GstElement * element, const gchar * host)
|
|
{
|
|
struct hostent *hostinfo;
|
|
char **addrs;
|
|
gchar *ip;
|
|
struct in_addr addr;
|
|
|
|
GST_DEBUG_OBJECT (element, "resolving host %s", host);
|
|
|
|
/* first check if it already is an IP address */
|
|
if (inet_aton (host, &addr)) {
|
|
ip = g_strdup (host);
|
|
goto beach;
|
|
}
|
|
/* FIXME: could do a localhost check here */
|
|
|
|
/* perform a name lookup */
|
|
if (!(hostinfo = gethostbyname (host)))
|
|
goto resolve_error;
|
|
|
|
if (hostinfo->h_addrtype != AF_INET)
|
|
goto not_ip;
|
|
|
|
addrs = hostinfo->h_addr_list;
|
|
|
|
/* There could be more than one IP address, but we just return the first */
|
|
ip = g_strdup (inet_ntoa (*(struct in_addr *) *addrs));
|
|
|
|
beach:
|
|
GST_DEBUG_OBJECT (element, "resolved to IP %s", ip);
|
|
return ip;
|
|
|
|
resolve_error:
|
|
{
|
|
GST_ELEMENT_ERROR (element, RESOURCE, NOT_FOUND, (NULL),
|
|
("Could not find IP address for host \"%s\".", host));
|
|
return NULL;
|
|
}
|
|
not_ip:
|
|
{
|
|
GST_ELEMENT_ERROR (element, RESOURCE, NOT_FOUND, (NULL),
|
|
("host \"%s\" is not an IP host", host));
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
/* write buffer to given socket incrementally.
|
|
* Returns number of bytes written.
|
|
*/
|
|
gint
|
|
gst_tcp_socket_write (int socket, const void *buf, size_t count)
|
|
{
|
|
size_t bytes_written = 0;
|
|
|
|
while (bytes_written < count) {
|
|
ssize_t wrote = send (socket, buf + bytes_written,
|
|
count - bytes_written, MSG_NOSIGNAL);
|
|
|
|
if (wrote <= 0) {
|
|
return bytes_written;
|
|
}
|
|
bytes_written += wrote;
|
|
}
|
|
|
|
if (bytes_written < 0)
|
|
GST_WARNING ("error while writing");
|
|
else
|
|
GST_LOG ("wrote %d bytes succesfully", bytes_written);
|
|
return bytes_written;
|
|
}
|
|
|
|
/* atomically read count bytes into buf, cancellable. return val of GST_FLOW_OK
|
|
* indicates success, anything else is failure.
|
|
*/
|
|
static GstFlowReturn
|
|
gst_tcp_socket_read (GstElement * this, int socket, void *buf, size_t count,
|
|
int cancel_fd)
|
|
{
|
|
fd_set testfds;
|
|
int maxfdp1;
|
|
ssize_t n;
|
|
size_t bytes_read;
|
|
int num_to_read;
|
|
|
|
bytes_read = 0;
|
|
|
|
while (bytes_read < count) {
|
|
/* do a blocking select on the socket */
|
|
FD_ZERO (&testfds);
|
|
FD_SET (socket, &testfds);
|
|
if (cancel_fd >= 0)
|
|
FD_SET (cancel_fd, &testfds);
|
|
maxfdp1 = MAX (socket, cancel_fd) + 1;
|
|
|
|
/* no action (0) is an error too in our case */
|
|
if (select (maxfdp1, &testfds, NULL, NULL, 0) <= 0)
|
|
goto select_error;
|
|
|
|
if (cancel_fd >= 0 && FD_ISSET (cancel_fd, &testfds))
|
|
goto cancelled;
|
|
|
|
/* ask how much is available for reading on the socket */
|
|
if (ioctl (socket, FIONREAD, &num_to_read) < 0)
|
|
goto ioctl_error;
|
|
|
|
if (num_to_read == 0)
|
|
goto got_eos;
|
|
|
|
/* sizeof(ssize_t) >= sizeof(int), so I know num_to_read <= SSIZE_MAX */
|
|
|
|
num_to_read = MIN (num_to_read, count - bytes_read);
|
|
|
|
n = read (socket, ((guint8 *) buf) + bytes_read, num_to_read);
|
|
|
|
if (n < 0)
|
|
goto read_error;
|
|
|
|
if (n < num_to_read)
|
|
goto short_read;
|
|
|
|
bytes_read += num_to_read;
|
|
}
|
|
|
|
return GST_FLOW_OK;
|
|
|
|
/* ERRORS */
|
|
select_error:
|
|
{
|
|
GST_ELEMENT_ERROR (this, RESOURCE, READ, (NULL),
|
|
("select failed: %s", g_strerror (errno)));
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
cancelled:
|
|
{
|
|
GST_DEBUG_OBJECT (this, "Select was cancelled");
|
|
return GST_FLOW_WRONG_STATE;
|
|
}
|
|
ioctl_error:
|
|
{
|
|
GST_ELEMENT_ERROR (this, RESOURCE, READ, (NULL),
|
|
("ioctl failed: %s", g_strerror (errno)));
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
got_eos:
|
|
{
|
|
GST_DEBUG_OBJECT (this, "Got EOS on socket stream");
|
|
return GST_FLOW_WRONG_STATE;
|
|
}
|
|
read_error:
|
|
{
|
|
GST_ELEMENT_ERROR (this, RESOURCE, READ, (NULL),
|
|
("read failed: %s", g_strerror (errno)));
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
short_read:
|
|
{
|
|
GST_ELEMENT_ERROR (this, RESOURCE, READ, (NULL),
|
|
("short read: wanted %d bytes, got %d", num_to_read, n));
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
}
|
|
|
|
/* close the socket and reset the fd. Used to clean up after errors. */
|
|
void
|
|
gst_tcp_socket_close (int *socket)
|
|
{
|
|
close (*socket);
|
|
*socket = -1;
|
|
}
|
|
|
|
/* read a buffer from the given socket
|
|
* returns:
|
|
* - a GstBuffer in which data should be read
|
|
* - NULL, indicating a connection close or an error, to be handled with
|
|
* EOS
|
|
*/
|
|
GstFlowReturn
|
|
gst_tcp_read_buffer (GstElement * this, int socket, int cancel_fd,
|
|
GstBuffer ** buf)
|
|
{
|
|
fd_set testfds;
|
|
int ret;
|
|
int maxfdp1;
|
|
ssize_t bytes_read;
|
|
int readsize;
|
|
|
|
*buf = NULL;
|
|
|
|
/* do a blocking select on the socket */
|
|
FD_ZERO (&testfds);
|
|
FD_SET (socket, &testfds);
|
|
if (cancel_fd >= 0)
|
|
FD_SET (cancel_fd, &testfds);
|
|
maxfdp1 = MAX (socket, cancel_fd) + 1;
|
|
|
|
/* no action (0) is an error too in our case */
|
|
if ((ret = select (maxfdp1, &testfds, NULL, NULL, 0)) <= 0)
|
|
goto select_error;
|
|
|
|
if (cancel_fd >= 0 && FD_ISSET (cancel_fd, &testfds))
|
|
goto cancelled;
|
|
|
|
/* ask how much is available for reading on the socket */
|
|
if ((ret = ioctl (socket, FIONREAD, &readsize)) < 0)
|
|
goto ioctl_error;
|
|
|
|
if (readsize == 0)
|
|
goto got_eos;
|
|
|
|
/* sizeof(ssize_t) >= sizeof(int), so I know readsize <= SSIZE_MAX */
|
|
|
|
*buf = gst_buffer_new_and_alloc (readsize);
|
|
|
|
bytes_read = read (socket, GST_BUFFER_DATA (*buf), readsize);
|
|
|
|
if (bytes_read < 0)
|
|
goto read_error;
|
|
|
|
if (bytes_read < readsize)
|
|
/* but mom, you promised to give me readsize bytes! */
|
|
goto short_read;
|
|
|
|
GST_DEBUG_OBJECT (this, "returning buffer of size %d", GST_BUFFER_SIZE (buf));
|
|
return GST_FLOW_OK;
|
|
|
|
/* ERRORS */
|
|
select_error:
|
|
{
|
|
GST_ELEMENT_ERROR (this, RESOURCE, READ, (NULL),
|
|
("select failed: %s", g_strerror (errno)));
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
cancelled:
|
|
{
|
|
GST_DEBUG_OBJECT (this, "Select was cancelled");
|
|
return GST_FLOW_WRONG_STATE;
|
|
}
|
|
ioctl_error:
|
|
{
|
|
GST_ELEMENT_ERROR (this, RESOURCE, READ, (NULL),
|
|
("ioctl failed: %s", g_strerror (errno)));
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
got_eos:
|
|
{
|
|
GST_DEBUG_OBJECT (this, "Got EOS on socket stream");
|
|
return GST_FLOW_WRONG_STATE;
|
|
}
|
|
read_error:
|
|
{
|
|
GST_ELEMENT_ERROR (this, RESOURCE, READ, (NULL),
|
|
("read failed: %s", g_strerror (errno)));
|
|
gst_buffer_unref (*buf);
|
|
*buf = NULL;
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
short_read:
|
|
{
|
|
GST_ELEMENT_ERROR (this, RESOURCE, READ, (NULL),
|
|
("short read: wanted %d bytes, got %d", readsize, bytes_read));
|
|
gst_buffer_unref (*buf);
|
|
*buf = NULL;
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
}
|
|
|
|
/* read a buffer from the given socket
|
|
* returns:
|
|
* - a GstBuffer in which data should be read
|
|
* - NULL, indicating a connection close or an error, to be handled with
|
|
* EOS
|
|
*/
|
|
GstFlowReturn
|
|
gst_tcp_gdp_read_buffer (GstElement * this, int socket, int cancel_fd,
|
|
GstBuffer ** buf)
|
|
{
|
|
GstFlowReturn ret;
|
|
guint8 *header = NULL;
|
|
|
|
GST_LOG_OBJECT (this, "Reading %d bytes for buffer packet header",
|
|
GST_DP_HEADER_LENGTH);
|
|
|
|
*buf = NULL;
|
|
header = g_malloc (GST_DP_HEADER_LENGTH);
|
|
|
|
ret = gst_tcp_socket_read (this, socket, header, GST_DP_HEADER_LENGTH,
|
|
cancel_fd);
|
|
|
|
if (ret != GST_FLOW_OK)
|
|
goto header_read_error;
|
|
|
|
if (!gst_dp_validate_header (GST_DP_HEADER_LENGTH, header))
|
|
goto validate_error;
|
|
|
|
if (gst_dp_header_payload_type (header) != GST_DP_PAYLOAD_BUFFER)
|
|
goto is_not_buffer;
|
|
|
|
GST_LOG_OBJECT (this, "validated buffer packet header");
|
|
|
|
*buf = gst_dp_buffer_from_header (GST_DP_HEADER_LENGTH, header);
|
|
|
|
g_free (header);
|
|
|
|
ret = gst_tcp_socket_read (this, socket, GST_BUFFER_DATA (*buf),
|
|
GST_BUFFER_SIZE (*buf), cancel_fd);
|
|
|
|
if (ret != GST_FLOW_OK)
|
|
goto data_read_error;
|
|
|
|
return GST_FLOW_OK;
|
|
|
|
/* ERRORS */
|
|
header_read_error:
|
|
{
|
|
g_free (header);
|
|
return ret;
|
|
}
|
|
validate_error:
|
|
{
|
|
GST_ELEMENT_ERROR (this, RESOURCE, READ, (NULL),
|
|
("GDP buffer packet header does not validate"));
|
|
g_free (header);
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
is_not_buffer:
|
|
{
|
|
GST_ELEMENT_ERROR (this, RESOURCE, READ, (NULL),
|
|
("GDP packet contains something that is not a buffer"));
|
|
g_free (header);
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
data_read_error:
|
|
{
|
|
gst_buffer_unref (*buf);
|
|
*buf = NULL;
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
GstFlowReturn
|
|
gst_tcp_gdp_read_caps (GstElement * this, int socket, int cancel_fd,
|
|
GstCaps ** caps)
|
|
{
|
|
GstFlowReturn ret;
|
|
guint8 *header = NULL;
|
|
guint8 *payload = NULL;
|
|
size_t payload_length;
|
|
|
|
GST_LOG_OBJECT (this, "Reading %d bytes for caps packet header",
|
|
GST_DP_HEADER_LENGTH);
|
|
|
|
*caps = NULL;
|
|
header = g_malloc (GST_DP_HEADER_LENGTH);
|
|
|
|
ret = gst_tcp_socket_read (this, socket, header, GST_DP_HEADER_LENGTH,
|
|
cancel_fd);
|
|
|
|
if (ret != GST_FLOW_OK)
|
|
goto header_read_error;
|
|
|
|
if (!gst_dp_validate_header (GST_DP_HEADER_LENGTH, header))
|
|
goto header_validate_error;
|
|
|
|
if (gst_dp_header_payload_type (header) != GST_DP_PAYLOAD_CAPS)
|
|
goto is_not_caps;
|
|
|
|
GST_LOG_OBJECT (this, "validated caps packet header");
|
|
|
|
payload_length = gst_dp_header_payload_length (header);
|
|
payload = g_malloc (payload_length);
|
|
|
|
GST_LOG_OBJECT (this, "Reading %d bytes for caps packet payload",
|
|
payload_length);
|
|
|
|
ret = gst_tcp_socket_read (this, socket, payload, payload_length, cancel_fd);
|
|
|
|
if (ret != GST_FLOW_OK)
|
|
goto payload_read_error;
|
|
|
|
if (!gst_dp_validate_payload (payload_length, header, payload))
|
|
goto payload_validate_error;
|
|
|
|
*caps = gst_dp_caps_from_packet (GST_DP_HEADER_LENGTH, header, payload);
|
|
|
|
GST_DEBUG_OBJECT (this, "Got caps over GDP: %" GST_PTR_FORMAT, *caps);
|
|
|
|
g_free (header);
|
|
g_free (payload);
|
|
|
|
return GST_FLOW_OK;
|
|
|
|
/* ERRORS */
|
|
header_read_error:
|
|
{
|
|
g_free (header);
|
|
return ret;
|
|
}
|
|
header_validate_error:
|
|
{
|
|
GST_ELEMENT_ERROR (this, RESOURCE, READ, (NULL),
|
|
("GDP caps packet header does not validate"));
|
|
g_free (header);
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
is_not_caps:
|
|
{
|
|
GST_ELEMENT_ERROR (this, RESOURCE, READ, (NULL),
|
|
("GDP packet contains something that is not a caps"));
|
|
g_free (header);
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
payload_read_error:
|
|
{
|
|
g_free (header);
|
|
g_free (payload);
|
|
return ret;
|
|
}
|
|
payload_validate_error:
|
|
{
|
|
GST_ELEMENT_ERROR (this, RESOURCE, READ, (NULL),
|
|
("GDP caps packet payload does not validate"));
|
|
g_free (header);
|
|
g_free (payload);
|
|
return GST_FLOW_ERROR;
|
|
}
|
|
}
|
|
|
|
/* write a GDP header to the socket. Return false if fails. */
|
|
gboolean
|
|
gst_tcp_gdp_write_buffer (GstElement * this, int socket, GstBuffer * buffer,
|
|
gboolean fatal, const gchar * host, int port)
|
|
{
|
|
guint length;
|
|
guint8 *header;
|
|
size_t wrote;
|
|
|
|
if (!gst_dp_header_from_buffer (buffer, 0, &length, &header))
|
|
goto create_error;
|
|
|
|
GST_LOG_OBJECT (this, "writing %d bytes for GDP buffer header", length);
|
|
wrote = gst_tcp_socket_write (socket, header, length);
|
|
g_free (header);
|
|
|
|
if (wrote != length)
|
|
goto write_error;
|
|
|
|
return TRUE;
|
|
|
|
/* ERRORS */
|
|
create_error:
|
|
{
|
|
if (fatal)
|
|
GST_ELEMENT_ERROR (this, CORE, TOO_LAZY, (NULL),
|
|
("Could not create GDP header from buffer"));
|
|
return FALSE;
|
|
}
|
|
write_error:
|
|
{
|
|
if (fatal)
|
|
GST_ELEMENT_ERROR (this, RESOURCE, WRITE,
|
|
(_("Error while sending data to \"%s:%d\"."), host, port),
|
|
("Only %d of %d bytes written: %s",
|
|
wrote, GST_BUFFER_SIZE (buffer), g_strerror (errno)));
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
/* write GDP header and payload to the given socket for the given caps.
|
|
* Return false if fails. */
|
|
gboolean
|
|
gst_tcp_gdp_write_caps (GstElement * this, int socket, const GstCaps * caps,
|
|
gboolean fatal, const char *host, int port)
|
|
{
|
|
guint length;
|
|
guint8 *header;
|
|
guint8 *payload;
|
|
size_t wrote;
|
|
|
|
if (!gst_dp_packet_from_caps (caps, 0, &length, &header, &payload))
|
|
goto create_error;
|
|
|
|
GST_LOG_OBJECT (this, "writing %d bytes for GDP caps header", length);
|
|
wrote = gst_tcp_socket_write (socket, header, length);
|
|
if (wrote != length)
|
|
goto write_header_error;
|
|
|
|
length = gst_dp_header_payload_length (header);
|
|
g_free (header);
|
|
|
|
GST_LOG_OBJECT (this, "writing %d bytes for GDP caps payload", length);
|
|
wrote = gst_tcp_socket_write (socket, payload, length);
|
|
g_free (payload);
|
|
|
|
if (wrote != length)
|
|
goto write_payload_error;
|
|
|
|
return TRUE;
|
|
|
|
/* ERRORS */
|
|
create_error:
|
|
{
|
|
if (fatal)
|
|
GST_ELEMENT_ERROR (this, CORE, TOO_LAZY, (NULL),
|
|
("Could not create GDP packet from caps"));
|
|
return FALSE;
|
|
}
|
|
write_header_error:
|
|
{
|
|
g_free (header);
|
|
g_free (payload);
|
|
if (fatal)
|
|
GST_ELEMENT_ERROR (this, RESOURCE, WRITE,
|
|
(_("Error while sending gdp header data to \"%s:%d\"."), host, port),
|
|
("Only %d of %d bytes written: %s",
|
|
wrote, length, g_strerror (errno)));
|
|
return FALSE;
|
|
}
|
|
write_payload_error:
|
|
{
|
|
if (fatal)
|
|
GST_ELEMENT_ERROR (this, RESOURCE, WRITE,
|
|
(_("Error while sending gdp payload data to \"%s:%d\"."), host, port),
|
|
("Only %d of %d bytes written: %s",
|
|
wrote, length, g_strerror (errno)));
|
|
return FALSE;
|
|
}
|
|
}
|