gst/tcp/gsttcpserversrc.c

   1 /* GStreamer
   2  * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
   3  * Copyright (C) <2004> Thomas Vander Stichele <thomas at apestaart dot org>
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 /**
  22  * SECTION:element-tcpserversrc
  23  * @see_also: #tcpserversink
  24  *
  25  * <refsect2>
  26  * <title>Example launch line</title>
  27  * |[
  28  * # server:
  29  * gst-launch tcpserversrc protocol=none port=3000 ! fdsink fd=2
  30  * # client:
  31  * gst-launch fdsrc fd=1 ! tcpclientsink protocol=none port=3000
  32  * ]|
  33  * </refsect2>
  34  */
  35
  36 #ifdef HAVE_CONFIG_H
  37 #include "config.h"
  38 #endif
  39
  40 #include <gst/gst-i18n-plugin.h>
  41 #include "gsttcp.h"
  42 #include "gsttcpserversrc.h"
  43 #include <string.h>             /* memset */
  44 #include <unistd.h>
  45 #include <sys/ioctl.h>
  46 #include <fcntl.h>
  47
  48
  49 GST_DEBUG_CATEGORY_STATIC (tcpserversrc_debug);
  50 #define GST_CAT_DEFAULT tcpserversrc_debug
  51
  52 #define TCP_DEFAULT_LISTEN_HOST         NULL    /* listen on all interfaces */
  53 #define TCP_BACKLOG                     1       /* client connection queue */
  54
  55
  56 static GstStaticPadTemplate srctemplate = GST_STATIC_PAD_TEMPLATE ("src",
  57     GST_PAD_SRC,
  58     GST_PAD_ALWAYS,
  59     GST_STATIC_CAPS_ANY);
  60
  61
  62 enum
  63 {
  64   PROP_0,
  65   PROP_HOST,
  66   PROP_PORT
  67 };
  68
  69
  70 GST_BOILERPLATE (GstTCPServerSrc, gst_tcp_server_src, GstPushSrc,
  71     GST_TYPE_PUSH_SRC);
  72
  73
  74 static void gst_tcp_server_src_finalize (GObject * gobject);
  75
  76 static gboolean gst_tcp_server_src_start (GstBaseSrc * bsrc);
  77 static gboolean gst_tcp_server_src_stop (GstBaseSrc * bsrc);
  78 static gboolean gst_tcp_server_src_unlock (GstBaseSrc * bsrc);
  79 static GstFlowReturn gst_tcp_server_src_create (GstPushSrc * psrc,
  80     GstBuffer ** buf);
  81
  82 static void gst_tcp_server_src_set_property (GObject * object, guint prop_id,
  83     const GValue * value, GParamSpec * pspec);
  84 static void gst_tcp_server_src_get_property (GObject * object, guint prop_id,
  85     GValue * value, GParamSpec * pspec);
  86
  87
  88 static void
  89 gst_tcp_server_src_base_init (gpointer g_class)
  90 {
  91   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
  92
  93   gst_element_class_add_pad_template (element_class,
  94       gst_static_pad_template_get (&srctemplate));
  95
  96   gst_element_class_set_details_simple (element_class,
  97       "TCP server source", "Source/Network",
  98       "Receive data as a server over the network via TCP",
  99       "Thomas Vander Stichele <thomas at apestaart dot org>");
 100 }
 101
 102 static void
 103 gst_tcp_server_src_class_init (GstTCPServerSrcClass * klass)
 104 {
 105   GObjectClass *gobject_class;
 106   GstBaseSrcClass *gstbasesrc_class;
 107   GstPushSrcClass *gstpush_src_class;
 108
 109   gobject_class = (GObjectClass *) klass;
 110   gstbasesrc_class = (GstBaseSrcClass *) klass;
 111   gstpush_src_class = (GstPushSrcClass *) klass;
 112
 113   gobject_class->set_property = gst_tcp_server_src_set_property;
 114   gobject_class->get_property = gst_tcp_server_src_get_property;
 115   gobject_class->finalize = gst_tcp_server_src_finalize;
 116
 117   g_object_class_install_property (gobject_class, PROP_HOST,
 118       g_param_spec_string ("host", "Host", "The hostname to listen as",
 119           TCP_DEFAULT_LISTEN_HOST, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 120   g_object_class_install_property (gobject_class, PROP_PORT,
 121       g_param_spec_int ("port", "Port", "The port to listen to",
 122           0, TCP_HIGHEST_PORT, TCP_DEFAULT_PORT,
 123           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 124
 125   gstbasesrc_class->start = gst_tcp_server_src_start;
 126   gstbasesrc_class->stop = gst_tcp_server_src_stop;
 127   gstbasesrc_class->unlock = gst_tcp_server_src_unlock;
 128
 129   gstpush_src_class->create = gst_tcp_server_src_create;
 130
 131   GST_DEBUG_CATEGORY_INIT (tcpserversrc_debug, "tcpserversrc", 0,
 132       "TCP Server Source");
 133 }
 134
 135 static void
 136 gst_tcp_server_src_init (GstTCPServerSrc * src, GstTCPServerSrcClass * g_class)
 137 {
 138   src->server_port = TCP_DEFAULT_PORT;
 139   src->host = g_strdup (TCP_DEFAULT_HOST);
 140   src->server_sock_fd.fd = -1;
 141   src->client_sock_fd.fd = -1;
 142
 143   GST_OBJECT_FLAG_UNSET (src, GST_TCP_SERVER_SRC_OPEN);
 144 }
 145
 146 static void
 147 gst_tcp_server_src_finalize (GObject * gobject)
 148 {
 149   GstTCPServerSrc *src = GST_TCP_SERVER_SRC (gobject);
 150
 151   g_free (src->host);
 152
 153   G_OBJECT_CLASS (parent_class)->finalize (gobject);
 154 }
 155
 156 static GstFlowReturn
 157 gst_tcp_server_src_create (GstPushSrc * psrc, GstBuffer ** outbuf)
 158 {
 159   GstTCPServerSrc *src;
 160   GstFlowReturn ret = GST_FLOW_OK;
 161
 162   src = GST_TCP_SERVER_SRC (psrc);
 163
 164   if (!GST_OBJECT_FLAG_IS_SET (src, GST_TCP_SERVER_SRC_OPEN))
 165     goto wrong_state;
 166
 167 restart:
 168   if (src->client_sock_fd.fd >= 0) {
 169     /* if we have a client, wait for read */
 170     gst_poll_fd_ctl_read (src->fdset, &src->server_sock_fd, FALSE);
 171     gst_poll_fd_ctl_read (src->fdset, &src->client_sock_fd, TRUE);
 172   } else {
 173     /* else wait on server socket for connections */
 174     gst_poll_fd_ctl_read (src->fdset, &src->server_sock_fd, TRUE);
 175   }
 176
 177   /* no action (0) is an error too in our case */
 178   if ((ret = gst_poll_wait (src->fdset, GST_CLOCK_TIME_NONE)) <= 0) {
 179     if (ret == -1 && errno == EBUSY)
 180       goto select_cancelled;
 181     else
 182       goto select_error;
 183   }
 184
 185   /* if we have no client socket we can accept one now */
 186   if (src->client_sock_fd.fd < 0) {
 187     if (gst_poll_fd_can_read (src->fdset, &src->server_sock_fd)) {
 188       if ((src->client_sock_fd.fd =
 189               accept (src->server_sock_fd.fd,
 190                   (struct sockaddr *) &src->client_sin,
 191                   &src->client_sin_len)) == -1)
 192         goto accept_error;
 193
 194       gst_poll_add_fd (src->fdset, &src->client_sock_fd);
 195     }
 196     /* and restart now to poll the socket. */
 197     goto restart;
 198   }
 199
 200   GST_LOG_OBJECT (src, "asked for a buffer");
 201
 202   ret = gst_tcp_read_buffer (GST_ELEMENT (src), src->client_sock_fd.fd,
 203       src->fdset, outbuf);
 204
 205   if (ret == GST_FLOW_OK) {
 206     GST_LOG_OBJECT (src,
 207         "Returning buffer from _get of size %d, ts %"
 208         GST_TIME_FORMAT ", dur %" GST_TIME_FORMAT
 209         ", offset %" G_GINT64_FORMAT ", offset_end %" G_GINT64_FORMAT,
 210         GST_BUFFER_SIZE (*outbuf),
 211         GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (*outbuf)),
 212         GST_TIME_ARGS (GST_BUFFER_DURATION (*outbuf)),
 213         GST_BUFFER_OFFSET (*outbuf), GST_BUFFER_OFFSET_END (*outbuf));
 214   }
 215
 216   return ret;
 217
 218 wrong_state:
 219   {
 220     GST_DEBUG_OBJECT (src, "connection to closed, cannot read data");
 221     return GST_FLOW_WRONG_STATE;
 222   }
 223 select_error:
 224   {
 225     GST_ELEMENT_ERROR (src, RESOURCE, READ, (NULL),
 226         ("Select error: %s", g_strerror (errno)));
 227     return GST_FLOW_ERROR;
 228   }
 229 select_cancelled:
 230   {
 231     GST_DEBUG_OBJECT (src, "select canceled");
 232     return GST_FLOW_WRONG_STATE;
 233   }
 234 accept_error:
 235   {
 236     GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL),
 237         ("Could not accept client on server socket: %s", g_strerror (errno)));
 238     return GST_FLOW_ERROR;
 239   }
 240 }
 241
 242 static void
 243 gst_tcp_server_src_set_property (GObject * object, guint prop_id,
 244     const GValue * value, GParamSpec * pspec)
 245 {
 246   GstTCPServerSrc *tcpserversrc = GST_TCP_SERVER_SRC (object);
 247
 248   switch (prop_id) {
 249     case PROP_HOST:
 250       if (!g_value_get_string (value)) {
 251         g_warning ("host property cannot be NULL");
 252         break;
 253       }
 254       g_free (tcpserversrc->host);
 255       tcpserversrc->host = g_strdup (g_value_get_string (value));
 256       break;
 257     case PROP_PORT:
 258       tcpserversrc->server_port = g_value_get_int (value);
 259       break;
 260
 261     default:
 262       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 263       break;
 264   }
 265 }
 266
 267 static void
 268 gst_tcp_server_src_get_property (GObject * object, guint prop_id,
 269     GValue * value, GParamSpec * pspec)
 270 {
 271   GstTCPServerSrc *tcpserversrc = GST_TCP_SERVER_SRC (object);
 272
 273   switch (prop_id) {
 274     case PROP_HOST:
 275       g_value_set_string (value, tcpserversrc->host);
 276       break;
 277     case PROP_PORT:
 278       g_value_set_int (value, tcpserversrc->server_port);
 279       break;
 280
 281     default:
 282       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 283       break;
 284   }
 285 }
 286
 287 /* set up server */
 288 static gboolean
 289 gst_tcp_server_src_start (GstBaseSrc * bsrc)
 290 {
 291   int ret;
 292   GstTCPServerSrc *src = GST_TCP_SERVER_SRC (bsrc);
 293
 294   /* reset caps_received flag */
 295   src->caps_received = FALSE;
 296
 297   /* create the server listener socket */
 298   if ((src->server_sock_fd.fd = socket (AF_INET, SOCK_STREAM, 0)) == -1)
 299     goto socket_error;
 300
 301   GST_DEBUG_OBJECT (src, "opened receiving server socket with fd %d",
 302       src->server_sock_fd.fd);
 303
 304   /* make address reusable */
 305   ret = 1;
 306   if (setsockopt (src->server_sock_fd.fd, SOL_SOCKET, SO_REUSEADDR, &ret,
 307           sizeof (int)) < 0)
 308     goto sock_opt;
 309
 310   /* name the socket */
 311   memset (&src->server_sin, 0, sizeof (src->server_sin));
 312   src->server_sin.sin_family = AF_INET; /* network socket */
 313   src->server_sin.sin_port = htons (src->server_port);  /* on port */
 314   if (src->host) {
 315     gchar *host;
 316
 317     if (!(host = gst_tcp_host_to_ip (GST_ELEMENT (src), src->host)))
 318       goto host_error;
 319     src->server_sin.sin_addr.s_addr = inet_addr (host);
 320     g_free (host);
 321   } else
 322     src->server_sin.sin_addr.s_addr = htonl (INADDR_ANY);
 323
 324   /* bind it */
 325   GST_DEBUG_OBJECT (src, "binding server socket to address");
 326   if ((ret = bind (src->server_sock_fd.fd, (struct sockaddr *) &src->server_sin,
 327               sizeof (src->server_sin))) < 0)
 328     goto bind_error;
 329
 330   GST_DEBUG_OBJECT (src, "listening on server socket %d with queue of %d",
 331       src->server_sock_fd.fd, TCP_BACKLOG);
 332
 333   if (listen (src->server_sock_fd.fd, TCP_BACKLOG) == -1)
 334     goto listen_error;
 335
 336   /* create an fdset to keep track of our file descriptors */
 337   if ((src->fdset = gst_poll_new (TRUE)) == NULL)
 338     goto socket_pair;
 339
 340   gst_poll_add_fd (src->fdset, &src->server_sock_fd);
 341
 342   GST_DEBUG_OBJECT (src, "received client");
 343
 344   GST_OBJECT_FLAG_SET (src, GST_TCP_SERVER_SRC_OPEN);
 345
 346   return TRUE;
 347
 348   /* ERRORS */
 349 socket_error:
 350   {
 351     GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL), GST_ERROR_SYSTEM);
 352     return FALSE;
 353   }
 354 sock_opt:
 355   {
 356     GST_ELEMENT_ERROR (src, RESOURCE, SETTINGS, (NULL),
 357         ("Could not setsockopt: %s", g_strerror (errno)));
 358     gst_tcp_socket_close (&src->server_sock_fd);
 359     return FALSE;
 360   }
 361 host_error:
 362   {
 363     gst_tcp_socket_close (&src->server_sock_fd);
 364     return FALSE;
 365   }
 366 bind_error:
 367   {
 368     gst_tcp_socket_close (&src->server_sock_fd);
 369     switch (errno) {
 370       default:
 371         GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL),
 372             ("bind failed: %s", g_strerror (errno)));
 373         break;
 374     }
 375     return FALSE;
 376   }
 377 listen_error:
 378   {
 379     gst_tcp_socket_close (&src->server_sock_fd);
 380     GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL),
 381         ("Could not listen on server socket: %s", g_strerror (errno)));
 382     return FALSE;
 383   }
 384 socket_pair:
 385   {
 386     GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ_WRITE, (NULL),
 387         GST_ERROR_SYSTEM);
 388     gst_tcp_socket_close (&src->server_sock_fd);
 389     return FALSE;
 390   }
 391 }
 392
 393 static gboolean
 394 gst_tcp_server_src_stop (GstBaseSrc * bsrc)
 395 {
 396   GstTCPServerSrc *src = GST_TCP_SERVER_SRC (bsrc);
 397
 398   gst_poll_free (src->fdset);
 399   src->fdset = NULL;
 400
 401   gst_tcp_socket_close (&src->server_sock_fd);
 402   gst_tcp_socket_close (&src->client_sock_fd);
 403
 404   GST_OBJECT_FLAG_UNSET (src, GST_TCP_SERVER_SRC_OPEN);
 405
 406   return TRUE;
 407 }
 408
 409 /* will be called only between calls to start() and stop() */
 410 static gboolean
 411 gst_tcp_server_src_unlock (GstBaseSrc * bsrc)
 412 {
 413   GstTCPServerSrc *src = GST_TCP_SERVER_SRC (bsrc);
 414
 415   gst_poll_set_flushing (src->fdset, TRUE);
 416
 417   return TRUE;
 418 }