Merge branch 'master' into 0.11
[platform/upstream/gstreamer.git] / gst / tcp / gsttcpclientsrc.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-tcpclientsrc
23  * @see_also: #tcpclientsink
24  *
25  * <refsect2>
26  * <title>Example launch line</title>
27  * |[
28  * # server:
29  * nc -l -p 3000
30  * # client:
31  * gst-launch tcpclientsrc protocol=none port=3000 ! fdsink fd=2
32  * ]| everything you type in the server is shown on the client
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 "gsttcpclientsrc.h"
43 #include <string.h>             /* memset */
44 #include <unistd.h>
45 #include <arpa/inet.h>
46 #include <fcntl.h>
47
48
49 GST_DEBUG_CATEGORY_STATIC (tcpclientsrc_debug);
50 #define GST_CAT_DEFAULT tcpclientsrc_debug
51
52 #define MAX_READ_SIZE                   4 * 1024
53
54
55 static GstStaticPadTemplate srctemplate = GST_STATIC_PAD_TEMPLATE ("src",
56     GST_PAD_SRC,
57     GST_PAD_ALWAYS,
58     GST_STATIC_CAPS_ANY);
59
60
61 enum
62 {
63   PROP_0,
64   PROP_HOST,
65   PROP_PORT
66 };
67
68 #define gst_tcp_client_src_parent_class parent_class
69 G_DEFINE_TYPE (GstTCPClientSrc, gst_tcp_client_src, GST_TYPE_PUSH_SRC);
70
71
72 static void gst_tcp_client_src_finalize (GObject * gobject);
73
74 static GstCaps *gst_tcp_client_src_getcaps (GstBaseSrc * psrc,
75     GstCaps * filter);
76
77 static GstFlowReturn gst_tcp_client_src_create (GstPushSrc * psrc,
78     GstBuffer ** outbuf);
79 static gboolean gst_tcp_client_src_stop (GstBaseSrc * bsrc);
80 static gboolean gst_tcp_client_src_start (GstBaseSrc * bsrc);
81 static gboolean gst_tcp_client_src_unlock (GstBaseSrc * bsrc);
82 static gboolean gst_tcp_client_src_unlock_stop (GstBaseSrc * bsrc);
83
84 static void gst_tcp_client_src_set_property (GObject * object, guint prop_id,
85     const GValue * value, GParamSpec * pspec);
86 static void gst_tcp_client_src_get_property (GObject * object, guint prop_id,
87     GValue * value, GParamSpec * pspec);
88
89 static void
90 gst_tcp_client_src_class_init (GstTCPClientSrcClass * klass)
91 {
92   GObjectClass *gobject_class;
93   GstElementClass *gstelement_class;
94   GstBaseSrcClass *gstbasesrc_class;
95   GstPushSrcClass *gstpush_src_class;
96
97   gobject_class = (GObjectClass *) klass;
98   gstelement_class = (GstElementClass *) klass;
99   gstbasesrc_class = (GstBaseSrcClass *) klass;
100   gstpush_src_class = (GstPushSrcClass *) klass;
101
102   gobject_class->set_property = gst_tcp_client_src_set_property;
103   gobject_class->get_property = gst_tcp_client_src_get_property;
104   gobject_class->finalize = gst_tcp_client_src_finalize;
105
106   g_object_class_install_property (gobject_class, PROP_HOST,
107       g_param_spec_string ("host", "Host",
108           "The host IP address to receive packets from", TCP_DEFAULT_HOST,
109           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
110   g_object_class_install_property (gobject_class, PROP_PORT,
111       g_param_spec_int ("port", "Port", "The port to receive packets from", 0,
112           TCP_HIGHEST_PORT, TCP_DEFAULT_PORT,
113           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
114
115   gst_element_class_add_pad_template (gstelement_class,
116       gst_static_pad_template_get (&srctemplate));
117
118   gst_element_class_set_details_simple (gstelement_class,
119       "TCP client source", "Source/Network",
120       "Receive data as a client over the network via TCP",
121       "Thomas Vander Stichele <thomas at apestaart dot org>");
122
123   gstbasesrc_class->get_caps = gst_tcp_client_src_getcaps;
124   gstbasesrc_class->start = gst_tcp_client_src_start;
125   gstbasesrc_class->stop = gst_tcp_client_src_stop;
126   gstbasesrc_class->unlock = gst_tcp_client_src_unlock;
127   gstbasesrc_class->unlock_stop = gst_tcp_client_src_unlock_stop;
128
129   gstpush_src_class->create = gst_tcp_client_src_create;
130
131   GST_DEBUG_CATEGORY_INIT (tcpclientsrc_debug, "tcpclientsrc", 0,
132       "TCP Client Source");
133 }
134
135 static void
136 gst_tcp_client_src_init (GstTCPClientSrc * this)
137 {
138   this->port = TCP_DEFAULT_PORT;
139   this->host = g_strdup (TCP_DEFAULT_HOST);
140   this->sock_fd.fd = -1;
141   this->caps = NULL;
142
143   GST_OBJECT_FLAG_UNSET (this, GST_TCP_CLIENT_SRC_OPEN);
144 }
145
146 static void
147 gst_tcp_client_src_finalize (GObject * gobject)
148 {
149   GstTCPClientSrc *this = GST_TCP_CLIENT_SRC (gobject);
150
151   g_free (this->host);
152
153   G_OBJECT_CLASS (parent_class)->finalize (gobject);
154 }
155
156 static GstCaps *
157 gst_tcp_client_src_getcaps (GstBaseSrc * bsrc, GstCaps * filter)
158 {
159   GstTCPClientSrc *src;
160   GstCaps *caps = NULL;
161
162   src = GST_TCP_CLIENT_SRC (bsrc);
163
164   if (!GST_OBJECT_FLAG_IS_SET (src, GST_TCP_CLIENT_SRC_OPEN))
165     caps = (filter ? gst_caps_ref (filter) : gst_caps_new_any ());
166   else if (src->caps && filter)
167     caps =
168         gst_caps_intersect_full (filter, src->caps, GST_CAPS_INTERSECT_FIRST);
169   else if (src->caps)
170     caps = gst_caps_copy (src->caps);
171   else
172     caps = (filter ? gst_caps_ref (filter) : gst_caps_new_any ());
173
174   GST_DEBUG_OBJECT (src, "returning caps %" GST_PTR_FORMAT, caps);
175   g_assert (GST_IS_CAPS (caps));
176   return caps;
177 }
178
179 static GstFlowReturn
180 gst_tcp_client_src_create (GstPushSrc * psrc, GstBuffer ** outbuf)
181 {
182   GstTCPClientSrc *src;
183   GstFlowReturn ret = GST_FLOW_OK;
184
185   src = GST_TCP_CLIENT_SRC (psrc);
186
187   if (!GST_OBJECT_FLAG_IS_SET (src, GST_TCP_CLIENT_SRC_OPEN))
188     goto wrong_state;
189
190   GST_LOG_OBJECT (src, "asked for a buffer");
191
192   /* read the buffer header */
193   ret = gst_tcp_read_buffer (GST_ELEMENT (src), src->sock_fd.fd,
194       src->fdset, outbuf);
195
196   if (ret == GST_FLOW_OK) {
197     GST_LOG_OBJECT (src,
198         "Returning buffer from _get of size %d, ts %"
199         GST_TIME_FORMAT ", dur %" GST_TIME_FORMAT
200         ", offset %" G_GINT64_FORMAT ", offset_end %" G_GINT64_FORMAT,
201         gst_buffer_get_size (*outbuf),
202         GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (*outbuf)),
203         GST_TIME_ARGS (GST_BUFFER_DURATION (*outbuf)),
204         GST_BUFFER_OFFSET (*outbuf), GST_BUFFER_OFFSET_END (*outbuf));
205   }
206
207   return ret;
208
209 wrong_state:
210   {
211     GST_DEBUG_OBJECT (src, "connection to closed, cannot read data");
212     return GST_FLOW_WRONG_STATE;
213   }
214 }
215
216 static void
217 gst_tcp_client_src_set_property (GObject * object, guint prop_id,
218     const GValue * value, GParamSpec * pspec)
219 {
220   GstTCPClientSrc *tcpclientsrc = GST_TCP_CLIENT_SRC (object);
221
222   switch (prop_id) {
223     case PROP_HOST:
224       if (!g_value_get_string (value)) {
225         g_warning ("host property cannot be NULL");
226         break;
227       }
228       g_free (tcpclientsrc->host);
229       tcpclientsrc->host = g_strdup (g_value_get_string (value));
230       break;
231     case PROP_PORT:
232       tcpclientsrc->port = g_value_get_int (value);
233       break;
234
235     default:
236       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
237       break;
238   }
239 }
240
241 static void
242 gst_tcp_client_src_get_property (GObject * object, guint prop_id,
243     GValue * value, GParamSpec * pspec)
244 {
245   GstTCPClientSrc *tcpclientsrc = GST_TCP_CLIENT_SRC (object);
246
247   switch (prop_id) {
248     case PROP_HOST:
249       g_value_set_string (value, tcpclientsrc->host);
250       break;
251     case PROP_PORT:
252       g_value_set_int (value, tcpclientsrc->port);
253       break;
254
255     default:
256       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
257       break;
258   }
259 }
260
261 /* create a socket for connecting to remote server */
262 static gboolean
263 gst_tcp_client_src_start (GstBaseSrc * bsrc)
264 {
265   int ret;
266   gchar *ip;
267   GstTCPClientSrc *src = GST_TCP_CLIENT_SRC (bsrc);
268
269   if ((src->fdset = gst_poll_new (TRUE)) == NULL)
270     goto socket_pair;
271
272   /* create receiving client socket */
273   GST_DEBUG_OBJECT (src, "opening receiving client socket to %s:%d",
274       src->host, src->port);
275
276   if ((src->sock_fd.fd = socket (AF_INET, SOCK_STREAM, 0)) == -1)
277     goto no_socket;
278
279   GST_DEBUG_OBJECT (src, "opened receiving client socket with fd %d",
280       src->sock_fd.fd);
281   GST_OBJECT_FLAG_SET (src, GST_TCP_CLIENT_SRC_OPEN);
282
283   /* look up name if we need to */
284   if (!(ip = gst_tcp_host_to_ip (GST_ELEMENT (src), src->host)))
285     goto name_resolv;
286
287   GST_DEBUG_OBJECT (src, "IP address for host %s is %s", src->host, ip);
288
289   /* connect to server */
290   memset (&src->server_sin, 0, sizeof (src->server_sin));
291   src->server_sin.sin_family = AF_INET; /* network socket */
292   src->server_sin.sin_port = htons (src->port); /* on port */
293   src->server_sin.sin_addr.s_addr = inet_addr (ip);     /* on host ip */
294   g_free (ip);
295
296   GST_DEBUG_OBJECT (src, "connecting to server");
297   ret = connect (src->sock_fd.fd, (struct sockaddr *) &src->server_sin,
298       sizeof (src->server_sin));
299   if (ret)
300     goto connect_failed;
301
302   /* add the socket to the poll */
303   gst_poll_add_fd (src->fdset, &src->sock_fd);
304   gst_poll_fd_ctl_read (src->fdset, &src->sock_fd, TRUE);
305
306   return TRUE;
307
308 socket_pair:
309   {
310     GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ_WRITE, (NULL),
311         GST_ERROR_SYSTEM);
312     return FALSE;
313   }
314 no_socket:
315   {
316     GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL), GST_ERROR_SYSTEM);
317     return FALSE;
318   }
319 name_resolv:
320   {
321     gst_tcp_client_src_stop (GST_BASE_SRC (src));
322     return FALSE;
323   }
324 connect_failed:
325   {
326     gst_tcp_client_src_stop (GST_BASE_SRC (src));
327     switch (errno) {
328       case ECONNREFUSED:
329         GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ,
330             (_("Connection to %s:%d refused."), src->host, src->port), (NULL));
331         break;
332       default:
333         GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL),
334             ("connect to %s:%d failed: %s", src->host, src->port,
335                 g_strerror (errno)));
336         break;
337     }
338     return FALSE;
339   }
340 }
341
342 /* close the socket and associated resources
343  * unset OPEN flag
344  * used both to recover from errors and go to NULL state */
345 static gboolean
346 gst_tcp_client_src_stop (GstBaseSrc * bsrc)
347 {
348   GstTCPClientSrc *src;
349
350   src = GST_TCP_CLIENT_SRC (bsrc);
351
352   GST_DEBUG_OBJECT (src, "closing socket");
353
354   if (src->fdset != NULL) {
355     gst_poll_free (src->fdset);
356     src->fdset = NULL;
357   }
358
359   gst_tcp_socket_close (&src->sock_fd);
360   src->caps_received = FALSE;
361   if (src->caps) {
362     gst_caps_unref (src->caps);
363     src->caps = NULL;
364   }
365   GST_OBJECT_FLAG_UNSET (src, GST_TCP_CLIENT_SRC_OPEN);
366
367   return TRUE;
368 }
369
370 /* will be called only between calls to start() and stop() */
371 static gboolean
372 gst_tcp_client_src_unlock (GstBaseSrc * bsrc)
373 {
374   GstTCPClientSrc *src = GST_TCP_CLIENT_SRC (bsrc);
375
376   GST_DEBUG_OBJECT (src, "set to flushing");
377   gst_poll_set_flushing (src->fdset, TRUE);
378
379   return TRUE;
380 }
381
382 /* will be called only between calls to start() and stop() */
383 static gboolean
384 gst_tcp_client_src_unlock_stop (GstBaseSrc * bsrc)
385 {
386   GstTCPClientSrc *src = GST_TCP_CLIENT_SRC (bsrc);
387
388   GST_DEBUG_OBJECT (src, "unset flushing");
389   gst_poll_set_flushing (src->fdset, FALSE);
390
391   return TRUE;
392 }