gst/tcp/gsttcpserversink.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 #ifdef HAVE_CONFIG_H
  22 #include "config.h"
  23 #endif
  24 #include <gst/gst-i18n-plugin.h>
  25
  26 #include <sys/ioctl.h>
  27
  28 #ifdef HAVE_FIONREAD_IN_SYS_FILIO
  29 #include <sys/filio.h>
  30 #endif
  31
  32 #include "gsttcp.h"
  33 #include "gsttcpserversink.h"
  34 #include "gsttcp-marshal.h"
  35
  36 #define TCP_BACKLOG             5
  37
  38 /* elementfactory information */
  39 static GstElementDetails gst_tcpserversink_details =
  40 GST_ELEMENT_DETAILS ("TCP Server sink",
  41     "Sink/Network",
  42     "Send data as a server over the network via TCP",
  43     "Thomas Vander Stichele <thomas at apestaart dot org>");
  44
  45 GST_DEBUG_CATEGORY (tcpserversink_debug);
  46 #define GST_CAT_DEFAULT (tcpserversink_debug)
  47
  48 enum
  49 {
  50   ARG_0,
  51   ARG_HOST,
  52   ARG_PORT,
  53 };
  54
  55 static void gst_tcpserversink_base_init (gpointer g_class);
  56 static void gst_tcpserversink_class_init (GstTCPServerSink * klass);
  57 static void gst_tcpserversink_init (GstTCPServerSink * tcpserversink);
  58 static void gst_tcpserversink_finalize (GObject * gobject);
  59
  60 static gboolean gst_tcpserversink_handle_wait (GstMultiFdSink * sink,
  61     GstFDSet * set);
  62 static gboolean gst_tcpserversink_init_send (GstMultiFdSink * this);
  63 static gboolean gst_tcpserversink_close (GstMultiFdSink * this);
  64 static void gst_tcpserversink_removed (GstMultiFdSink * sink, int fd);
  65
  66 static void gst_tcpserversink_set_property (GObject * object, guint prop_id,
  67     const GValue * value, GParamSpec * pspec);
  68 static void gst_tcpserversink_get_property (GObject * object, guint prop_id,
  69     GValue * value, GParamSpec * pspec);
  70
  71
  72 static GstMultiFdSinkClass *parent_class = NULL;
  73
  74 GType
  75 gst_tcpserversink_get_type (void)
  76 {
  77   static GType tcpserversink_type = 0;
  78
  79
  80   if (!tcpserversink_type) {
  81     static const GTypeInfo tcpserversink_info = {
  82       sizeof (GstTCPServerSinkClass),
  83       gst_tcpserversink_base_init,
  84       NULL,
  85       (GClassInitFunc) gst_tcpserversink_class_init,
  86       NULL,
  87       NULL,
  88       sizeof (GstTCPServerSink),
  89       0,
  90       (GInstanceInitFunc) gst_tcpserversink_init,
  91       NULL
  92     };
  93
  94     tcpserversink_type =
  95         g_type_register_static (GST_TYPE_MULTIFDSINK, "GstTCPServerSink",
  96         &tcpserversink_info, 0);
  97   }
  98   return tcpserversink_type;
  99 }
 100
 101 static void
 102 gst_tcpserversink_base_init (gpointer g_class)
 103 {
 104   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
 105
 106   gst_element_class_set_details (element_class, &gst_tcpserversink_details);
 107 }
 108
 109 static void
 110 gst_tcpserversink_class_init (GstTCPServerSink * klass)
 111 {
 112   GObjectClass *gobject_class;
 113   GstElementClass *gstelement_class;
 114   GstMultiFdSinkClass *gstmultifdsink_class;
 115
 116   gobject_class = (GObjectClass *) klass;
 117   gstelement_class = (GstElementClass *) klass;
 118   gstmultifdsink_class = (GstMultiFdSinkClass *) klass;
 119
 120   parent_class = g_type_class_ref (GST_TYPE_MULTIFDSINK);
 121
 122   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_HOST,
 123       g_param_spec_string ("host", "host", "The host/IP to send the packets to",
 124           TCP_DEFAULT_HOST, G_PARAM_READWRITE));
 125   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_PORT,
 126       g_param_spec_int ("port", "port", "The port to send the packets to",
 127           0, TCP_HIGHEST_PORT, TCP_DEFAULT_PORT, G_PARAM_READWRITE));
 128
 129   gobject_class->set_property = gst_tcpserversink_set_property;
 130   gobject_class->get_property = gst_tcpserversink_get_property;
 131   gobject_class->finalize = gst_tcpserversink_finalize;
 132
 133   gstmultifdsink_class->init = gst_tcpserversink_init_send;
 134   gstmultifdsink_class->wait = gst_tcpserversink_handle_wait;
 135   gstmultifdsink_class->close = gst_tcpserversink_close;
 136   gstmultifdsink_class->removed = gst_tcpserversink_removed;
 137
 138   GST_DEBUG_CATEGORY_INIT (tcpserversink_debug, "tcpserversink", 0, "TCP sink");
 139 }
 140
 141 static void
 142 gst_tcpserversink_init (GstTCPServerSink * this)
 143 {
 144   this->server_port = TCP_DEFAULT_PORT;
 145   /* should support as minimum 576 for IPV4 and 1500 for IPV6 */
 146   /* this->mtu = 1500; */
 147   this->host = g_strdup (TCP_DEFAULT_HOST);
 148
 149   this->server_sock.fd = -1;
 150 }
 151
 152 static void
 153 gst_tcpserversink_finalize (GObject * gobject)
 154 {
 155   GstTCPServerSink *this = GST_TCPSERVERSINK (gobject);
 156
 157   g_free (this->host);
 158 }
 159
 160 /* handle a read request on the server,
 161  * which indicates a new client connection */
 162 static gboolean
 163 gst_tcpserversink_handle_server_read (GstTCPServerSink * sink)
 164 {
 165   /* new client */
 166   int client_sock_fd;
 167   struct sockaddr_in client_address;
 168   int client_address_len;
 169
 170   /* For some stupid reason, client_address and client_address_len has to be
 171    * zeroed */
 172   memset (&client_address, 0, sizeof (client_address));
 173   client_address_len = 0;
 174
 175   client_sock_fd =
 176       accept (sink->server_sock.fd, (struct sockaddr *) &client_address,
 177       &client_address_len);
 178   if (client_sock_fd == -1) {
 179     GST_ELEMENT_ERROR (sink, RESOURCE, OPEN_WRITE, (NULL),
 180         ("Could not accept client on server socket %d: %s (%d)",
 181             sink->server_sock.fd, g_strerror (errno), errno));
 182     return FALSE;
 183   }
 184
 185   gst_multifdsink_add (GST_MULTIFDSINK (sink), client_sock_fd);
 186
 187   GST_DEBUG_OBJECT (sink, "added new client ip %s with fd %d",
 188       inet_ntoa (client_address.sin_addr), client_sock_fd);
 189
 190   return TRUE;
 191 }
 192
 193 static void
 194 gst_tcpserversink_removed (GstMultiFdSink * sink, int fd)
 195 {
 196   GstTCPServerSink *this = GST_TCPSERVERSINK (sink);
 197
 198   GST_LOG_OBJECT (this, "closing fd %d", fd);
 199   if (close (fd) < 0) {
 200     GST_WARNING_OBJECT (this, "error closing fd %d: %s", fd,
 201         g_strerror (errno));
 202   }
 203 }
 204
 205 static gboolean
 206 gst_tcpserversink_handle_wait (GstMultiFdSink * sink, GstFDSet * set)
 207 {
 208   GstTCPServerSink *this = GST_TCPSERVERSINK (sink);
 209
 210   if (gst_fdset_fd_can_read (set, &this->server_sock)) {
 211     /* handle new client connection on server socket */
 212     if (!gst_tcpserversink_handle_server_read (this)) {
 213       GST_ELEMENT_ERROR (this, RESOURCE, READ, (NULL),
 214           ("client connection failed: %s", g_strerror (errno)));
 215       return FALSE;
 216     }
 217   }
 218   return TRUE;
 219 }
 220
 221 static void
 222 gst_tcpserversink_set_property (GObject * object, guint prop_id,
 223     const GValue * value, GParamSpec * pspec)
 224 {
 225   GstTCPServerSink *sink;
 226
 227   g_return_if_fail (GST_IS_TCPSERVERSINK (object));
 228   sink = GST_TCPSERVERSINK (object);
 229
 230   switch (prop_id) {
 231     case ARG_HOST:
 232       if (!g_value_get_string (value)) {
 233         g_warning ("host property cannot be NULL");
 234         break;
 235       }
 236       g_free (sink->host);
 237       sink->host = g_strdup (g_value_get_string (value));
 238       break;
 239     case ARG_PORT:
 240       sink->server_port = g_value_get_int (value);
 241       break;
 242
 243     default:
 244       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 245       break;
 246   }
 247 }
 248
 249 static void
 250 gst_tcpserversink_get_property (GObject * object, guint prop_id, GValue * value,
 251     GParamSpec * pspec)
 252 {
 253   GstTCPServerSink *sink;
 254
 255   g_return_if_fail (GST_IS_TCPSERVERSINK (object));
 256   sink = GST_TCPSERVERSINK (object);
 257
 258   switch (prop_id) {
 259     case ARG_HOST:
 260       g_value_set_string (value, sink->host);
 261       break;
 262     case ARG_PORT:
 263       g_value_set_int (value, sink->server_port);
 264       break;
 265
 266     default:
 267       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 268       break;
 269   }
 270 }
 271
 272
 273 /* create a socket for sending to remote machine */
 274 static gboolean
 275 gst_tcpserversink_init_send (GstMultiFdSink * parent)
 276 {
 277   int ret;
 278   GstTCPServerSink *this = GST_TCPSERVERSINK (parent);
 279
 280   /* create sending server socket */
 281   if ((this->server_sock.fd = socket (AF_INET, SOCK_STREAM, 0)) == -1) {
 282     GST_ELEMENT_ERROR (this, RESOURCE, OPEN_WRITE, (NULL), GST_ERROR_SYSTEM);
 283     return FALSE;
 284   }
 285   GST_DEBUG_OBJECT (this, "opened sending server socket with fd %d",
 286       this->server_sock.fd);
 287
 288   /* make address reusable */
 289   ret = 1;
 290   if (setsockopt (this->server_sock.fd, SOL_SOCKET, SO_REUSEADDR,
 291           (void *) &ret, sizeof (ret)) < 0) {
 292     gst_tcp_socket_close (&this->server_sock.fd);
 293     GST_ELEMENT_ERROR (this, RESOURCE, SETTINGS, (NULL),
 294         ("Could not setsockopt: %s", g_strerror (errno)));
 295     return FALSE;
 296   }
 297   /* keep connection alive; avoids SIGPIPE during write */
 298   ret = 1;
 299   if (setsockopt (this->server_sock.fd, SOL_SOCKET, SO_KEEPALIVE,
 300           (void *) &ret, sizeof (ret)) < 0) {
 301     gst_tcp_socket_close (&this->server_sock.fd);
 302     GST_ELEMENT_ERROR (this, RESOURCE, SETTINGS, (NULL),
 303         ("Could not setsockopt: %s", g_strerror (errno)));
 304     return FALSE;
 305   }
 306
 307   /* name the socket */
 308   memset (&this->server_sin, 0, sizeof (this->server_sin));
 309   this->server_sin.sin_family = AF_INET;        /* network socket */
 310   this->server_sin.sin_port = htons (this->server_port);        /* on port */
 311   this->server_sin.sin_addr.s_addr = htonl (INADDR_ANY);        /* for hosts */
 312
 313   /* bind it */
 314   GST_DEBUG_OBJECT (this, "binding server socket to address");
 315   ret = bind (this->server_sock.fd, (struct sockaddr *) &this->server_sin,
 316       sizeof (this->server_sin));
 317
 318   if (ret) {
 319     gst_tcp_socket_close (&this->server_sock.fd);
 320     switch (errno) {
 321       default:
 322         GST_ELEMENT_ERROR (this, RESOURCE, OPEN_READ, (NULL),
 323             ("bind on port %d failed: %s", this->server_port,
 324                 g_strerror (errno)));
 325         return FALSE;
 326         break;
 327     }
 328   }
 329
 330   /* set the server socket to nonblocking */
 331   fcntl (this->server_sock.fd, F_SETFL, O_NONBLOCK);
 332
 333   GST_DEBUG_OBJECT (this, "listening on server socket %d with queue of %d",
 334       this->server_sock.fd, TCP_BACKLOG);
 335   if (listen (this->server_sock.fd, TCP_BACKLOG) == -1) {
 336     gst_tcp_socket_close (&this->server_sock.fd);
 337     GST_ELEMENT_ERROR (this, RESOURCE, OPEN_READ, (NULL),
 338         ("Could not listen on server socket: %s", g_strerror (errno)));
 339     return FALSE;
 340   }
 341   GST_DEBUG_OBJECT (this,
 342       "listened on server socket %d, returning from connection setup",
 343       this->server_sock.fd);
 344
 345   gst_fdset_add_fd (parent->fdset, &this->server_sock);
 346   gst_fdset_fd_ctl_read (parent->fdset, &this->server_sock, TRUE);
 347
 348   return TRUE;
 349 }
 350
 351 static gboolean
 352 gst_tcpserversink_close (GstMultiFdSink * parent)
 353 {
 354   GstTCPServerSink *this = GST_TCPSERVERSINK (parent);
 355
 356   if (this->server_sock.fd != -1) {
 357     gst_fdset_remove_fd (parent->fdset, &this->server_sock);
 358
 359     close (this->server_sock.fd);
 360     this->server_sock.fd = -1;
 361   }
 362   return TRUE;
 363 }