souphttpsrc: reduce reading latency by using non-blocking read
[platform/upstream/gst-plugins-good.git] / ext / soup / gstsouphttpsrc.c
1 /* GStreamer
2  * Copyright (C) 2007-2008 Wouter Cloetens <wouter@mind.be>
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Library General Public
6  * License as published by the Free Software Foundation; either
7  * version 2 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Library General Public License for more
13  */
14
15 /**
16  * SECTION:element-souphttpsrc
17  *
18  * This plugin reads data from a remote location specified by a URI.
19  * Supported protocols are 'http', 'https'.
20  *
21  * An HTTP proxy must be specified by its URL.
22  * If the "http_proxy" environment variable is set, its value is used.
23  * If built with libsoup's GNOME integration features, the GNOME proxy
24  * configuration will be used, or failing that, proxy autodetection.
25  * The #GstSoupHTTPSrc:proxy property can be used to override the default.
26  *
27  * In case the #GstSoupHTTPSrc:iradio-mode property is set and the location is
28  * an HTTP resource, souphttpsrc will send special Icecast HTTP headers to the
29  * server to request additional Icecast meta-information.
30  * If the server is not an Icecast server, it will behave as if the
31  * #GstSoupHTTPSrc:iradio-mode property were not set. If it is, souphttpsrc will
32  * output data with a media type of application/x-icy, in which case you will
33  * need to use the #ICYDemux element as follow-up element to extract the Icecast
34  * metadata and to determine the underlying media type.
35  *
36  * <refsect2>
37  * <title>Example launch line</title>
38  * |[
39  * gst-launch-1.0 -v souphttpsrc location=https://some.server.org/index.html
40  *     ! filesink location=/home/joe/server.html
41  * ]| The above pipeline reads a web page from a server using the HTTPS protocol
42  * and writes it to a local file.
43  * |[
44  * gst-launch-1.0 -v souphttpsrc user-agent="FooPlayer 0.99 beta"
45  *     automatic-redirect=false proxy=http://proxy.intranet.local:8080
46  *     location=http://music.foobar.com/demo.mp3 ! mad ! audioconvert
47  *     ! audioresample ! alsasink
48  * ]| The above pipeline will read and decode and play an mp3 file from a
49  * web server using the HTTP protocol. If the server sends redirects,
50  * the request fails instead of following the redirect. The specified
51  * HTTP proxy server is used. The User-Agent HTTP request header
52  * is set to a custom string instead of "GStreamer souphttpsrc."
53  * |[
54  * gst-launch-1.0 -v souphttpsrc location=http://10.11.12.13/mjpeg
55  *     do-timestamp=true ! multipartdemux
56  *     ! image/jpeg,width=640,height=480 ! matroskamux
57  *     ! filesink location=mjpeg.mkv
58  * ]| The above pipeline reads a motion JPEG stream from an IP camera
59  * using the HTTP protocol, encoded as mime/multipart image/jpeg
60  * parts, and writes a Matroska motion JPEG file. The width and
61  * height properties are set in the caps to provide the Matroska
62  * multiplexer with the information to set this in the header.
63  * Timestamps are set on the buffers as they arrive from the camera.
64  * These are used by the mime/multipart demultiplexer to emit timestamps
65  * on the JPEG-encoded video frame buffers. This allows the Matroska
66  * multiplexer to timestamp the frames in the resulting file.
67  * </refsect2>
68  */
69
70 #ifdef HAVE_CONFIG_H
71 #include "config.h"
72 #endif
73
74 #include <string.h>
75 #ifdef HAVE_STDLIB_H
76 #include <stdlib.h>             /* atoi() */
77 #endif
78 #include <gst/gstelement.h>
79 #include <gst/gst-i18n-plugin.h>
80 #include <gio/gio.h>
81 #include <libsoup/soup.h>
82 #include "gstsouphttpsrc.h"
83 #include "gstsouputils.h"
84
85 #include <gst/tag/tag.h>
86
87 GST_DEBUG_CATEGORY_STATIC (souphttpsrc_debug);
88 #define GST_CAT_DEFAULT souphttpsrc_debug
89
90 static GstStaticPadTemplate srctemplate = GST_STATIC_PAD_TEMPLATE ("src",
91     GST_PAD_SRC,
92     GST_PAD_ALWAYS,
93     GST_STATIC_CAPS_ANY);
94
95 enum
96 {
97   PROP_0,
98   PROP_LOCATION,
99   PROP_IS_LIVE,
100   PROP_USER_AGENT,
101   PROP_AUTOMATIC_REDIRECT,
102   PROP_PROXY,
103   PROP_USER_ID,
104   PROP_USER_PW,
105   PROP_PROXY_ID,
106   PROP_PROXY_PW,
107   PROP_COOKIES,
108   PROP_IRADIO_MODE,
109   PROP_TIMEOUT,
110   PROP_EXTRA_HEADERS,
111   PROP_SOUP_LOG_LEVEL,
112   PROP_COMPRESS,
113   PROP_KEEP_ALIVE,
114   PROP_SSL_STRICT,
115   PROP_SSL_CA_FILE,
116   PROP_SSL_USE_SYSTEM_CA_FILE,
117   PROP_TLS_DATABASE,
118   PROP_RETRIES,
119   PROP_METHOD,
120   PROP_TLS_INTERACTION,
121 };
122
123 #define DEFAULT_USER_AGENT           "GStreamer souphttpsrc "
124 #define DEFAULT_IRADIO_MODE          TRUE
125 #define DEFAULT_SOUP_LOG_LEVEL       SOUP_LOGGER_LOG_HEADERS
126 #define DEFAULT_COMPRESS             FALSE
127 #define DEFAULT_KEEP_ALIVE           FALSE
128 #define DEFAULT_SSL_STRICT           TRUE
129 #define DEFAULT_SSL_CA_FILE          NULL
130 #define DEFAULT_SSL_USE_SYSTEM_CA_FILE TRUE
131 #define DEFAULT_TLS_DATABASE         NULL
132 #define DEFAULT_TLS_INTERACTION      NULL
133 #define DEFAULT_TIMEOUT              15
134 #define DEFAULT_RETRIES              3
135 #define DEFAULT_SOUP_METHOD          NULL
136
137 static void gst_soup_http_src_uri_handler_init (gpointer g_iface,
138     gpointer iface_data);
139 static void gst_soup_http_src_finalize (GObject * gobject);
140 static void gst_soup_http_src_dispose (GObject * gobject);
141
142 static void gst_soup_http_src_set_property (GObject * object, guint prop_id,
143     const GValue * value, GParamSpec * pspec);
144 static void gst_soup_http_src_get_property (GObject * object, guint prop_id,
145     GValue * value, GParamSpec * pspec);
146
147 static GstStateChangeReturn gst_soup_http_src_change_state (GstElement *
148     element, GstStateChange transition);
149 static GstFlowReturn gst_soup_http_src_create (GstPushSrc * psrc,
150     GstBuffer ** outbuf);
151 static gboolean gst_soup_http_src_start (GstBaseSrc * bsrc);
152 static gboolean gst_soup_http_src_stop (GstBaseSrc * bsrc);
153 static gboolean gst_soup_http_src_get_size (GstBaseSrc * bsrc, guint64 * size);
154 static gboolean gst_soup_http_src_is_seekable (GstBaseSrc * bsrc);
155 static gboolean gst_soup_http_src_do_seek (GstBaseSrc * bsrc,
156     GstSegment * segment);
157 static gboolean gst_soup_http_src_query (GstBaseSrc * bsrc, GstQuery * query);
158 static gboolean gst_soup_http_src_unlock (GstBaseSrc * bsrc);
159 static gboolean gst_soup_http_src_unlock_stop (GstBaseSrc * bsrc);
160 static gboolean gst_soup_http_src_set_location (GstSoupHTTPSrc * src,
161     const gchar * uri, GError ** error);
162 static gboolean gst_soup_http_src_set_proxy (GstSoupHTTPSrc * src,
163     const gchar * uri);
164 static char *gst_soup_http_src_unicodify (const char *str);
165 static gboolean gst_soup_http_src_build_message (GstSoupHTTPSrc * src,
166     const gchar * method);
167 static void gst_soup_http_src_cancel_message (GstSoupHTTPSrc * src);
168 static gboolean gst_soup_http_src_add_range_header (GstSoupHTTPSrc * src,
169     guint64 offset, guint64 stop_offset);
170 static gboolean gst_soup_http_src_session_open (GstSoupHTTPSrc * src);
171 static void gst_soup_http_src_session_close (GstSoupHTTPSrc * src);
172 static void gst_soup_http_src_parse_status (SoupMessage * msg,
173     GstSoupHTTPSrc * src);
174 static void gst_soup_http_src_got_headers (GstSoupHTTPSrc * src,
175     SoupMessage * msg);
176 static void gst_soup_http_src_authenticate_cb (SoupSession * session,
177     SoupMessage * msg, SoupAuth * auth, gboolean retrying,
178     GstSoupHTTPSrc * src);
179 static void gst_soup_http_src_destroy_input_stream (GstSoupHTTPSrc * src);
180
181 #define gst_soup_http_src_parent_class parent_class
182 G_DEFINE_TYPE_WITH_CODE (GstSoupHTTPSrc, gst_soup_http_src, GST_TYPE_PUSH_SRC,
183     G_IMPLEMENT_INTERFACE (GST_TYPE_URI_HANDLER,
184         gst_soup_http_src_uri_handler_init));
185
186 static void
187 gst_soup_http_src_class_init (GstSoupHTTPSrcClass * klass)
188 {
189   GObjectClass *gobject_class;
190   GstElementClass *gstelement_class;
191   GstBaseSrcClass *gstbasesrc_class;
192   GstPushSrcClass *gstpushsrc_class;
193
194   gobject_class = (GObjectClass *) klass;
195   gstelement_class = (GstElementClass *) klass;
196   gstbasesrc_class = (GstBaseSrcClass *) klass;
197   gstpushsrc_class = (GstPushSrcClass *) klass;
198
199   gobject_class->set_property = gst_soup_http_src_set_property;
200   gobject_class->get_property = gst_soup_http_src_get_property;
201   gobject_class->finalize = gst_soup_http_src_finalize;
202   gobject_class->dispose = gst_soup_http_src_dispose;
203
204   g_object_class_install_property (gobject_class,
205       PROP_LOCATION,
206       g_param_spec_string ("location", "Location",
207           "Location to read from", "",
208           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
209   g_object_class_install_property (gobject_class,
210       PROP_USER_AGENT,
211       g_param_spec_string ("user-agent", "User-Agent",
212           "Value of the User-Agent HTTP request header field",
213           DEFAULT_USER_AGENT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
214   g_object_class_install_property (gobject_class,
215       PROP_AUTOMATIC_REDIRECT,
216       g_param_spec_boolean ("automatic-redirect", "automatic-redirect",
217           "Automatically follow HTTP redirects (HTTP Status Code 3xx)",
218           TRUE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
219   g_object_class_install_property (gobject_class,
220       PROP_PROXY,
221       g_param_spec_string ("proxy", "Proxy",
222           "HTTP proxy server URI", "",
223           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
224   g_object_class_install_property (gobject_class,
225       PROP_USER_ID,
226       g_param_spec_string ("user-id", "user-id",
227           "HTTP location URI user id for authentication", "",
228           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
229   g_object_class_install_property (gobject_class, PROP_USER_PW,
230       g_param_spec_string ("user-pw", "user-pw",
231           "HTTP location URI user password for authentication", "",
232           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
233   g_object_class_install_property (gobject_class, PROP_PROXY_ID,
234       g_param_spec_string ("proxy-id", "proxy-id",
235           "HTTP proxy URI user id for authentication", "",
236           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
237   g_object_class_install_property (gobject_class, PROP_PROXY_PW,
238       g_param_spec_string ("proxy-pw", "proxy-pw",
239           "HTTP proxy URI user password for authentication", "",
240           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
241   g_object_class_install_property (gobject_class, PROP_COOKIES,
242       g_param_spec_boxed ("cookies", "Cookies", "HTTP request cookies",
243           G_TYPE_STRV, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
244   g_object_class_install_property (gobject_class, PROP_IS_LIVE,
245       g_param_spec_boolean ("is-live", "is-live", "Act like a live source",
246           FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
247   g_object_class_install_property (gobject_class, PROP_TIMEOUT,
248       g_param_spec_uint ("timeout", "timeout",
249           "Value in seconds to timeout a blocking I/O (0 = No timeout).", 0,
250           3600, DEFAULT_TIMEOUT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
251   g_object_class_install_property (gobject_class, PROP_EXTRA_HEADERS,
252       g_param_spec_boxed ("extra-headers", "Extra Headers",
253           "Extra headers to append to the HTTP request",
254           GST_TYPE_STRUCTURE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
255   g_object_class_install_property (gobject_class, PROP_IRADIO_MODE,
256       g_param_spec_boolean ("iradio-mode", "iradio-mode",
257           "Enable internet radio mode (ask server to send shoutcast/icecast "
258           "metadata interleaved with the actual stream data)",
259           DEFAULT_IRADIO_MODE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
260
261  /**
262    * GstSoupHTTPSrc::http-log-level:
263    *
264    * If set and > 0, captures and dumps HTTP session data as
265    * log messages if log level >= GST_LEVEL_TRACE
266    *
267    * Since: 1.4
268    */
269   g_object_class_install_property (gobject_class, PROP_SOUP_LOG_LEVEL,
270       g_param_spec_enum ("http-log-level", "HTTP log level",
271           "Set log level for soup's HTTP session log",
272           SOUP_TYPE_LOGGER_LOG_LEVEL, DEFAULT_SOUP_LOG_LEVEL,
273           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
274
275  /**
276    * GstSoupHTTPSrc::compress:
277    *
278    * If set to %TRUE, souphttpsrc will automatically handle gzip
279    * and deflate Content-Encodings. This does not make much difference
280    * and causes more load for normal media files, but makes a real
281    * difference in size for plaintext files.
282    *
283    * Since: 1.4
284    */
285   g_object_class_install_property (gobject_class, PROP_COMPRESS,
286       g_param_spec_boolean ("compress", "Compress",
287           "Allow compressed content encodings",
288           DEFAULT_COMPRESS, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
289
290  /**
291    * GstSoupHTTPSrc::keep-alive:
292    *
293    * If set to %TRUE, souphttpsrc will keep alive connections when being
294    * set to READY state and only will close connections when connecting
295    * to a different server or when going to NULL state..
296    *
297    * Since: 1.4
298    */
299   g_object_class_install_property (gobject_class, PROP_KEEP_ALIVE,
300       g_param_spec_boolean ("keep-alive", "keep-alive",
301           "Use HTTP persistent connections", DEFAULT_KEEP_ALIVE,
302           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
303
304  /**
305    * GstSoupHTTPSrc::ssl-strict:
306    *
307    * If set to %TRUE, souphttpsrc will reject all SSL certificates that
308    * are considered invalid.
309    *
310    * Since: 1.4
311    */
312   g_object_class_install_property (gobject_class, PROP_SSL_STRICT,
313       g_param_spec_boolean ("ssl-strict", "SSL Strict",
314           "Strict SSL certificate checking", DEFAULT_SSL_STRICT,
315           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
316
317  /**
318    * GstSoupHTTPSrc::ssl-ca-file:
319    *
320    * A SSL anchor CA file that should be used for checking certificates
321    * instead of the system CA file.
322    *
323    * If this property is non-%NULL, #GstSoupHTTPSrc::ssl-use-system-ca-file
324    * value will be ignored.
325    *
326    * Deprecated: Use #GstSoupHTTPSrc::tls-database property instead.
327    * Since: 1.4
328    */
329   g_object_class_install_property (gobject_class, PROP_SSL_CA_FILE,
330       g_param_spec_string ("ssl-ca-file", "SSL CA File",
331           "Location of a SSL anchor CA file to use", DEFAULT_SSL_CA_FILE,
332           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
333
334  /**
335    * GstSoupHTTPSrc::ssl-use-system-ca-file:
336    *
337    * If set to %TRUE, souphttpsrc will use the system's CA file for
338    * checking certificates, unless #GstSoupHTTPSrc::ssl-ca-file or
339    * #GstSoupHTTPSrc::tls-database are non-%NULL.
340    *
341    * Since: 1.4
342    */
343   g_object_class_install_property (gobject_class, PROP_SSL_USE_SYSTEM_CA_FILE,
344       g_param_spec_boolean ("ssl-use-system-ca-file", "Use System CA File",
345           "Use system CA file", DEFAULT_SSL_USE_SYSTEM_CA_FILE,
346           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
347
348   /**
349    * GstSoupHTTPSrc::tls-database:
350    *
351    * TLS database with anchor certificate authorities used to validate
352    * the server certificate.
353    *
354    * If this property is non-%NULL, #GstSoupHTTPSrc::ssl-use-system-ca-file
355    * and #GstSoupHTTPSrc::ssl-ca-file values will be ignored.
356    *
357    * Since: 1.6
358    */
359   g_object_class_install_property (gobject_class, PROP_TLS_DATABASE,
360       g_param_spec_object ("tls-database", "TLS database",
361           "TLS database with anchor certificate authorities used to validate the server certificate",
362           G_TYPE_TLS_DATABASE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
363
364   /**
365    * GstSoupHTTPSrc::tls-interaction:
366    *
367    * A #GTlsInteraction object to be used when the connection or certificate
368    * database need to interact with the user. This will be used to prompt the
369    * user for passwords or certificate where necessary.
370    *
371    * Since: 1.8
372    */
373   g_object_class_install_property (gobject_class, PROP_TLS_INTERACTION,
374       g_param_spec_object ("tls-interaction", "TLS interaction",
375           "A GTlsInteraction object to be used when the connection or certificate database need to interact with the user.",
376           G_TYPE_TLS_INTERACTION, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
377
378  /**
379    * GstSoupHTTPSrc::retries:
380    *
381    * Maximum number of retries until giving up.
382    *
383    * Since: 1.4
384    */
385   g_object_class_install_property (gobject_class, PROP_RETRIES,
386       g_param_spec_int ("retries", "Retries",
387           "Maximum number of retries until giving up (-1=infinite)", -1,
388           G_MAXINT, DEFAULT_RETRIES,
389           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
390
391  /**
392    * GstSoupHTTPSrc::method
393    *
394    * The HTTP method to use when making a request
395    *
396    * Since: 1.6
397    */
398   g_object_class_install_property (gobject_class, PROP_METHOD,
399       g_param_spec_string ("method", "HTTP method",
400           "The HTTP method to use (GET, HEAD, OPTIONS, etc)",
401           DEFAULT_SOUP_METHOD, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
402
403   gst_element_class_add_static_pad_template (gstelement_class, &srctemplate);
404
405   gst_element_class_set_static_metadata (gstelement_class, "HTTP client source",
406       "Source/Network",
407       "Receive data as a client over the network via HTTP using SOUP",
408       "Wouter Cloetens <wouter@mind.be>");
409   gstelement_class->change_state =
410       GST_DEBUG_FUNCPTR (gst_soup_http_src_change_state);
411
412   gstbasesrc_class->start = GST_DEBUG_FUNCPTR (gst_soup_http_src_start);
413   gstbasesrc_class->stop = GST_DEBUG_FUNCPTR (gst_soup_http_src_stop);
414   gstbasesrc_class->unlock = GST_DEBUG_FUNCPTR (gst_soup_http_src_unlock);
415   gstbasesrc_class->unlock_stop =
416       GST_DEBUG_FUNCPTR (gst_soup_http_src_unlock_stop);
417   gstbasesrc_class->get_size = GST_DEBUG_FUNCPTR (gst_soup_http_src_get_size);
418   gstbasesrc_class->is_seekable =
419       GST_DEBUG_FUNCPTR (gst_soup_http_src_is_seekable);
420   gstbasesrc_class->do_seek = GST_DEBUG_FUNCPTR (gst_soup_http_src_do_seek);
421   gstbasesrc_class->query = GST_DEBUG_FUNCPTR (gst_soup_http_src_query);
422
423   gstpushsrc_class->create = GST_DEBUG_FUNCPTR (gst_soup_http_src_create);
424
425   GST_DEBUG_CATEGORY_INIT (souphttpsrc_debug, "souphttpsrc", 0,
426       "SOUP HTTP src");
427 }
428
429 static void
430 gst_soup_http_src_reset (GstSoupHTTPSrc * src)
431 {
432   src->retry_count = 0;
433   src->have_size = FALSE;
434   src->got_headers = FALSE;
435   src->seekable = FALSE;
436   src->read_position = 0;
437   src->request_position = 0;
438   src->stop_position = -1;
439   src->content_size = 0;
440   src->have_body = FALSE;
441
442   src->ret = GST_FLOW_OK;
443   g_cancellable_reset (src->cancellable);
444   gst_soup_http_src_destroy_input_stream (src);
445
446   gst_caps_replace (&src->src_caps, NULL);
447   g_free (src->iradio_name);
448   src->iradio_name = NULL;
449   g_free (src->iradio_genre);
450   src->iradio_genre = NULL;
451   g_free (src->iradio_url);
452   src->iradio_url = NULL;
453 }
454
455 static void
456 gst_soup_http_src_init (GstSoupHTTPSrc * src)
457 {
458   const gchar *proxy;
459
460   g_mutex_init (&src->mutex);
461   g_cond_init (&src->have_headers_cond);
462   src->cancellable = g_cancellable_new ();
463   src->poll_context = g_main_context_new ();
464   src->location = NULL;
465   src->redirection_uri = NULL;
466   src->automatic_redirect = TRUE;
467   src->user_agent = g_strdup (DEFAULT_USER_AGENT);
468   src->user_id = NULL;
469   src->user_pw = NULL;
470   src->proxy_id = NULL;
471   src->proxy_pw = NULL;
472   src->cookies = NULL;
473   src->iradio_mode = DEFAULT_IRADIO_MODE;
474   src->session = NULL;
475   src->msg = NULL;
476   src->timeout = DEFAULT_TIMEOUT;
477   src->log_level = DEFAULT_SOUP_LOG_LEVEL;
478   src->ssl_strict = DEFAULT_SSL_STRICT;
479   src->ssl_use_system_ca_file = DEFAULT_SSL_USE_SYSTEM_CA_FILE;
480   src->tls_database = DEFAULT_TLS_DATABASE;
481   src->tls_interaction = DEFAULT_TLS_INTERACTION;
482   src->max_retries = DEFAULT_RETRIES;
483   src->method = DEFAULT_SOUP_METHOD;
484   proxy = g_getenv ("http_proxy");
485   if (!gst_soup_http_src_set_proxy (src, proxy)) {
486     GST_WARNING_OBJECT (src,
487         "The proxy in the http_proxy env var (\"%s\") cannot be parsed.",
488         proxy);
489   }
490
491   gst_base_src_set_automatic_eos (GST_BASE_SRC (src), FALSE);
492
493   gst_soup_http_src_reset (src);
494 }
495
496 static void
497 gst_soup_http_src_dispose (GObject * gobject)
498 {
499   GstSoupHTTPSrc *src = GST_SOUP_HTTP_SRC (gobject);
500
501   GST_DEBUG_OBJECT (src, "dispose");
502
503   gst_soup_http_src_session_close (src);
504
505   G_OBJECT_CLASS (parent_class)->dispose (gobject);
506 }
507
508 static void
509 gst_soup_http_src_finalize (GObject * gobject)
510 {
511   GstSoupHTTPSrc *src = GST_SOUP_HTTP_SRC (gobject);
512
513   GST_DEBUG_OBJECT (src, "finalize");
514
515   g_mutex_clear (&src->mutex);
516   g_cond_clear (&src->have_headers_cond);
517   g_object_unref (src->cancellable);
518   g_main_context_unref (src->poll_context);
519   g_free (src->location);
520   g_free (src->redirection_uri);
521   g_free (src->user_agent);
522   if (src->proxy != NULL) {
523     soup_uri_free (src->proxy);
524   }
525   g_free (src->user_id);
526   g_free (src->user_pw);
527   g_free (src->proxy_id);
528   g_free (src->proxy_pw);
529   g_strfreev (src->cookies);
530
531   if (src->extra_headers) {
532     gst_structure_free (src->extra_headers);
533     src->extra_headers = NULL;
534   }
535
536   g_free (src->ssl_ca_file);
537
538   if (src->tls_database)
539     g_object_unref (src->tls_database);
540   g_free (src->method);
541
542   if (src->tls_interaction)
543     g_object_unref (src->tls_interaction);
544
545   G_OBJECT_CLASS (parent_class)->finalize (gobject);
546 }
547
548 static void
549 gst_soup_http_src_set_property (GObject * object, guint prop_id,
550     const GValue * value, GParamSpec * pspec)
551 {
552   GstSoupHTTPSrc *src = GST_SOUP_HTTP_SRC (object);
553
554   switch (prop_id) {
555     case PROP_LOCATION:
556     {
557       const gchar *location;
558
559       location = g_value_get_string (value);
560
561       if (location == NULL) {
562         GST_WARNING ("location property cannot be NULL");
563         goto done;
564       }
565       if (!gst_soup_http_src_set_location (src, location, NULL)) {
566         GST_WARNING ("badly formatted location");
567         goto done;
568       }
569       break;
570     }
571     case PROP_USER_AGENT:
572       g_free (src->user_agent);
573       src->user_agent = g_value_dup_string (value);
574       break;
575     case PROP_IRADIO_MODE:
576       src->iradio_mode = g_value_get_boolean (value);
577       break;
578     case PROP_AUTOMATIC_REDIRECT:
579       src->automatic_redirect = g_value_get_boolean (value);
580       break;
581     case PROP_PROXY:
582     {
583       const gchar *proxy;
584
585       proxy = g_value_get_string (value);
586       if (!gst_soup_http_src_set_proxy (src, proxy)) {
587         GST_WARNING ("badly formatted proxy URI");
588         goto done;
589       }
590       break;
591     }
592     case PROP_COOKIES:
593       g_strfreev (src->cookies);
594       src->cookies = g_strdupv (g_value_get_boxed (value));
595       break;
596     case PROP_IS_LIVE:
597       gst_base_src_set_live (GST_BASE_SRC (src), g_value_get_boolean (value));
598       break;
599     case PROP_USER_ID:
600       g_free (src->user_id);
601       src->user_id = g_value_dup_string (value);
602       break;
603     case PROP_USER_PW:
604       g_free (src->user_pw);
605       src->user_pw = g_value_dup_string (value);
606       break;
607     case PROP_PROXY_ID:
608       g_free (src->proxy_id);
609       src->proxy_id = g_value_dup_string (value);
610       break;
611     case PROP_PROXY_PW:
612       g_free (src->proxy_pw);
613       src->proxy_pw = g_value_dup_string (value);
614       break;
615     case PROP_TIMEOUT:
616       src->timeout = g_value_get_uint (value);
617       break;
618     case PROP_EXTRA_HEADERS:{
619       const GstStructure *s = gst_value_get_structure (value);
620
621       if (src->extra_headers)
622         gst_structure_free (src->extra_headers);
623
624       src->extra_headers = s ? gst_structure_copy (s) : NULL;
625       break;
626     }
627     case PROP_SOUP_LOG_LEVEL:
628       src->log_level = g_value_get_enum (value);
629       break;
630     case PROP_COMPRESS:
631       src->compress = g_value_get_boolean (value);
632       break;
633     case PROP_KEEP_ALIVE:
634       src->keep_alive = g_value_get_boolean (value);
635       break;
636     case PROP_SSL_STRICT:
637       src->ssl_strict = g_value_get_boolean (value);
638       break;
639     case PROP_SSL_CA_FILE:
640       g_free (src->ssl_ca_file);
641       src->ssl_ca_file = g_value_dup_string (value);
642       break;
643     case PROP_SSL_USE_SYSTEM_CA_FILE:
644       src->ssl_use_system_ca_file = g_value_get_boolean (value);
645       break;
646     case PROP_TLS_DATABASE:
647       g_clear_object (&src->tls_database);
648       src->tls_database = g_value_dup_object (value);
649       break;
650     case PROP_TLS_INTERACTION:
651       g_clear_object (&src->tls_interaction);
652       src->tls_interaction = g_value_dup_object (value);
653       break;
654     case PROP_RETRIES:
655       src->max_retries = g_value_get_int (value);
656       break;
657     case PROP_METHOD:
658       g_free (src->method);
659       src->method = g_value_dup_string (value);
660       break;
661     default:
662       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
663       break;
664   }
665 done:
666   return;
667 }
668
669 static void
670 gst_soup_http_src_get_property (GObject * object, guint prop_id,
671     GValue * value, GParamSpec * pspec)
672 {
673   GstSoupHTTPSrc *src = GST_SOUP_HTTP_SRC (object);
674
675   switch (prop_id) {
676     case PROP_LOCATION:
677       g_value_set_string (value, src->location);
678       break;
679     case PROP_USER_AGENT:
680       g_value_set_string (value, src->user_agent);
681       break;
682     case PROP_AUTOMATIC_REDIRECT:
683       g_value_set_boolean (value, src->automatic_redirect);
684       break;
685     case PROP_PROXY:
686       if (src->proxy == NULL)
687         g_value_set_static_string (value, "");
688       else {
689         char *proxy = soup_uri_to_string (src->proxy, FALSE);
690
691         g_value_set_string (value, proxy);
692         g_free (proxy);
693       }
694       break;
695     case PROP_COOKIES:
696       g_value_set_boxed (value, g_strdupv (src->cookies));
697       break;
698     case PROP_IS_LIVE:
699       g_value_set_boolean (value, gst_base_src_is_live (GST_BASE_SRC (src)));
700       break;
701     case PROP_IRADIO_MODE:
702       g_value_set_boolean (value, src->iradio_mode);
703       break;
704     case PROP_USER_ID:
705       g_value_set_string (value, src->user_id);
706       break;
707     case PROP_USER_PW:
708       g_value_set_string (value, src->user_pw);
709       break;
710     case PROP_PROXY_ID:
711       g_value_set_string (value, src->proxy_id);
712       break;
713     case PROP_PROXY_PW:
714       g_value_set_string (value, src->proxy_pw);
715       break;
716     case PROP_TIMEOUT:
717       g_value_set_uint (value, src->timeout);
718       break;
719     case PROP_EXTRA_HEADERS:
720       gst_value_set_structure (value, src->extra_headers);
721       break;
722     case PROP_SOUP_LOG_LEVEL:
723       g_value_set_enum (value, src->log_level);
724       break;
725     case PROP_COMPRESS:
726       g_value_set_boolean (value, src->compress);
727       break;
728     case PROP_KEEP_ALIVE:
729       g_value_set_boolean (value, src->keep_alive);
730       break;
731     case PROP_SSL_STRICT:
732       g_value_set_boolean (value, src->ssl_strict);
733       break;
734     case PROP_SSL_CA_FILE:
735       g_value_set_string (value, src->ssl_ca_file);
736       break;
737     case PROP_SSL_USE_SYSTEM_CA_FILE:
738       g_value_set_boolean (value, src->ssl_use_system_ca_file);
739       break;
740     case PROP_TLS_DATABASE:
741       g_value_set_object (value, src->tls_database);
742       break;
743     case PROP_TLS_INTERACTION:
744       g_value_set_object (value, src->tls_interaction);
745       break;
746     case PROP_RETRIES:
747       g_value_set_int (value, src->max_retries);
748       break;
749     case PROP_METHOD:
750       g_value_set_string (value, src->method);
751       break;
752     default:
753       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
754       break;
755   }
756 }
757
758 static gchar *
759 gst_soup_http_src_unicodify (const gchar * str)
760 {
761   const gchar *env_vars[] = { "GST_ICY_TAG_ENCODING",
762     "GST_TAG_ENCODING", NULL
763   };
764
765   return gst_tag_freeform_string_to_utf8 (str, -1, env_vars);
766 }
767
768 static void
769 gst_soup_http_src_destroy_input_stream (GstSoupHTTPSrc * src)
770 {
771   if (src->input_stream) {
772     if (src->poll_source) {
773       g_source_destroy (src->poll_source);
774       g_source_unref (src->poll_source);
775       src->poll_source = NULL;
776     }
777     g_input_stream_close (src->input_stream, src->cancellable, NULL);
778     g_object_unref (src->input_stream);
779     src->input_stream = NULL;
780   }
781 }
782
783 static void
784 gst_soup_http_src_cancel_message (GstSoupHTTPSrc * src)
785 {
786   g_cancellable_cancel (src->cancellable);
787   g_cond_signal (&src->have_headers_cond);
788 }
789
790 static gboolean
791 gst_soup_http_src_add_range_header (GstSoupHTTPSrc * src, guint64 offset,
792     guint64 stop_offset)
793 {
794   gchar buf[64];
795   gint rc;
796
797   soup_message_headers_remove (src->msg->request_headers, "Range");
798   if (offset || stop_offset != -1) {
799     if (stop_offset != -1) {
800       g_assert (offset != stop_offset);
801
802       rc = g_snprintf (buf, sizeof (buf), "bytes=%" G_GUINT64_FORMAT "-%"
803           G_GUINT64_FORMAT, offset, (stop_offset > 0) ? stop_offset - 1 :
804           stop_offset);
805     } else {
806       rc = g_snprintf (buf, sizeof (buf), "bytes=%" G_GUINT64_FORMAT "-",
807           offset);
808     }
809     if (rc > sizeof (buf) || rc < 0)
810       return FALSE;
811     soup_message_headers_append (src->msg->request_headers, "Range", buf);
812   }
813   src->read_position = offset;
814   return TRUE;
815 }
816
817 static gboolean
818 _append_extra_header (GQuark field_id, const GValue * value, gpointer user_data)
819 {
820   GstSoupHTTPSrc *src = GST_SOUP_HTTP_SRC (user_data);
821   const gchar *field_name = g_quark_to_string (field_id);
822   gchar *field_content = NULL;
823
824   if (G_VALUE_TYPE (value) == G_TYPE_STRING) {
825     field_content = g_value_dup_string (value);
826   } else {
827     GValue dest = { 0, };
828
829     g_value_init (&dest, G_TYPE_STRING);
830     if (g_value_transform (value, &dest)) {
831       field_content = g_value_dup_string (&dest);
832     }
833   }
834
835   if (field_content == NULL) {
836     GST_ERROR_OBJECT (src, "extra-headers field '%s' contains no value "
837         "or can't be converted to a string", field_name);
838     return FALSE;
839   }
840
841   GST_DEBUG_OBJECT (src, "Appending extra header: \"%s: %s\"", field_name,
842       field_content);
843   soup_message_headers_append (src->msg->request_headers, field_name,
844       field_content);
845
846   g_free (field_content);
847
848   return TRUE;
849 }
850
851 static gboolean
852 _append_extra_headers (GQuark field_id, const GValue * value,
853     gpointer user_data)
854 {
855   if (G_VALUE_TYPE (value) == GST_TYPE_ARRAY) {
856     guint n = gst_value_array_get_size (value);
857     guint i;
858
859     for (i = 0; i < n; i++) {
860       const GValue *v = gst_value_array_get_value (value, i);
861
862       if (!_append_extra_header (field_id, v, user_data))
863         return FALSE;
864     }
865   } else if (G_VALUE_TYPE (value) == GST_TYPE_LIST) {
866     guint n = gst_value_list_get_size (value);
867     guint i;
868
869     for (i = 0; i < n; i++) {
870       const GValue *v = gst_value_list_get_value (value, i);
871
872       if (!_append_extra_header (field_id, v, user_data))
873         return FALSE;
874     }
875   } else {
876     return _append_extra_header (field_id, value, user_data);
877   }
878
879   return TRUE;
880 }
881
882
883 static gboolean
884 gst_soup_http_src_add_extra_headers (GstSoupHTTPSrc * src)
885 {
886   if (!src->extra_headers)
887     return TRUE;
888
889   return gst_structure_foreach (src->extra_headers, _append_extra_headers, src);
890 }
891
892 static gboolean
893 gst_soup_http_src_session_open (GstSoupHTTPSrc * src)
894 {
895   if (src->session) {
896     GST_DEBUG_OBJECT (src, "Session is already open");
897     return TRUE;
898   }
899
900   if (!src->location) {
901     GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (_("No URL set.")),
902         ("Missing location property"));
903     return FALSE;
904   }
905
906   if (!src->session) {
907     GST_DEBUG_OBJECT (src, "Creating session");
908     if (src->proxy == NULL) {
909       src->session =
910           soup_session_new_with_options (SOUP_SESSION_USER_AGENT,
911           src->user_agent, SOUP_SESSION_TIMEOUT, src->timeout,
912           SOUP_SESSION_SSL_STRICT, src->ssl_strict,
913           SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_PROXY_RESOLVER_DEFAULT,
914           SOUP_SESSION_TLS_INTERACTION, src->tls_interaction, NULL);
915     } else {
916       src->session =
917           soup_session_new_with_options (SOUP_SESSION_PROXY_URI, src->proxy,
918           SOUP_SESSION_TIMEOUT, src->timeout,
919           SOUP_SESSION_SSL_STRICT, src->ssl_strict,
920           SOUP_SESSION_USER_AGENT, src->user_agent,
921           SOUP_SESSION_TLS_INTERACTION, src->tls_interaction, NULL);
922     }
923
924     if (!src->session) {
925       GST_ELEMENT_ERROR (src, LIBRARY, INIT,
926           (NULL), ("Failed to create async session"));
927       return FALSE;
928     }
929
930     g_signal_connect (src->session, "authenticate",
931         G_CALLBACK (gst_soup_http_src_authenticate_cb), src);
932
933     /* Set up logging */
934     gst_soup_util_log_setup (src->session, src->log_level, GST_ELEMENT (src));
935     if (src->tls_database)
936       g_object_set (src->session, "tls-database", src->tls_database, NULL);
937     else if (src->ssl_ca_file)
938       g_object_set (src->session, "ssl-ca-file", src->ssl_ca_file, NULL);
939     else
940       g_object_set (src->session, "ssl-use-system-ca-file",
941           src->ssl_use_system_ca_file, NULL);
942   } else {
943     GST_DEBUG_OBJECT (src, "Re-using session");
944   }
945
946   if (src->compress)
947     soup_session_add_feature_by_type (src->session, SOUP_TYPE_CONTENT_DECODER);
948   else
949     soup_session_remove_feature_by_type (src->session,
950         SOUP_TYPE_CONTENT_DECODER);
951
952   return TRUE;
953 }
954
955 static void
956 gst_soup_http_src_session_close (GstSoupHTTPSrc * src)
957 {
958   GST_DEBUG_OBJECT (src, "Closing session");
959
960   g_mutex_lock (&src->mutex);
961   if (src->session) {
962     soup_session_abort (src->session);  /* This unrefs the message. */
963     g_object_unref (src->session);
964     src->session = NULL;
965     src->msg = NULL;
966   }
967   g_mutex_unlock (&src->mutex);
968 }
969
970 static void
971 gst_soup_http_src_authenticate_cb (SoupSession * session, SoupMessage * msg,
972     SoupAuth * auth, gboolean retrying, GstSoupHTTPSrc * src)
973 {
974   if (!retrying) {
975     /* First time authentication only, if we fail and are called again with retry true fall through */
976     if (msg->status_code == SOUP_STATUS_UNAUTHORIZED) {
977       if (src->user_id && src->user_pw)
978         soup_auth_authenticate (auth, src->user_id, src->user_pw);
979     } else if (msg->status_code == SOUP_STATUS_PROXY_AUTHENTICATION_REQUIRED) {
980       if (src->proxy_id && src->proxy_pw)
981         soup_auth_authenticate (auth, src->proxy_id, src->proxy_pw);
982     }
983   }
984 }
985
986 static void
987 insert_http_header (const gchar * name, const gchar * value, gpointer user_data)
988 {
989   GstStructure *headers = user_data;
990   const GValue *gv;
991
992   gv = gst_structure_get_value (headers, name);
993   if (gv && GST_VALUE_HOLDS_ARRAY (gv)) {
994     GValue v = G_VALUE_INIT;
995
996     g_value_init (&v, G_TYPE_STRING);
997     g_value_set_string (&v, value);
998     gst_value_array_append_value ((GValue *) gv, &v);
999     g_value_unset (&v);
1000   } else if (gv && G_VALUE_HOLDS_STRING (gv)) {
1001     GValue arr = G_VALUE_INIT;
1002     GValue v = G_VALUE_INIT;
1003     const gchar *old_value = g_value_get_string (gv);
1004
1005     g_value_init (&arr, GST_TYPE_ARRAY);
1006     g_value_init (&v, G_TYPE_STRING);
1007     g_value_set_string (&v, old_value);
1008     gst_value_array_append_value (&arr, &v);
1009     g_value_set_string (&v, value);
1010     gst_value_array_append_value (&arr, &v);
1011
1012     gst_structure_set_value (headers, name, &arr);
1013     g_value_unset (&v);
1014     g_value_unset (&arr);
1015   } else {
1016     gst_structure_set (headers, name, G_TYPE_STRING, value, NULL);
1017   }
1018 }
1019
1020 static void
1021 gst_soup_http_src_got_headers (GstSoupHTTPSrc * src, SoupMessage * msg)
1022 {
1023   const char *value;
1024   GstTagList *tag_list;
1025   GstBaseSrc *basesrc;
1026   guint64 newsize;
1027   GHashTable *params = NULL;
1028   GstEvent *http_headers_event;
1029   GstStructure *http_headers, *headers;
1030   const gchar *accept_ranges;
1031
1032   GST_INFO_OBJECT (src, "got headers");
1033
1034   if (msg->status_code == SOUP_STATUS_PROXY_AUTHENTICATION_REQUIRED &&
1035       src->proxy_id && src->proxy_pw)
1036     return;
1037
1038   if (src->automatic_redirect && SOUP_STATUS_IS_REDIRECTION (msg->status_code)) {
1039     src->redirection_uri = g_strdup (soup_message_headers_get_one
1040         (msg->response_headers, "Location"));
1041     src->redirection_permanent =
1042         (msg->status_code == SOUP_STATUS_MOVED_PERMANENTLY);
1043     GST_DEBUG_OBJECT (src, "%u redirect to \"%s\" (permanent %d)",
1044         msg->status_code, src->redirection_uri, src->redirection_permanent);
1045     return;
1046   }
1047
1048   if (msg->status_code == SOUP_STATUS_UNAUTHORIZED) {
1049     /* force an error */
1050     gst_soup_http_src_parse_status (msg, src);
1051     return;
1052   }
1053
1054   src->got_headers = TRUE;
1055   g_cond_broadcast (&src->have_headers_cond);
1056
1057   http_headers = gst_structure_new_empty ("http-headers");
1058   gst_structure_set (http_headers, "uri", G_TYPE_STRING, src->location, NULL);
1059   if (src->redirection_uri)
1060     gst_structure_set (http_headers, "redirection-uri", G_TYPE_STRING,
1061         src->redirection_uri, NULL);
1062   headers = gst_structure_new_empty ("request-headers");
1063   soup_message_headers_foreach (msg->request_headers, insert_http_header,
1064       headers);
1065   gst_structure_set (http_headers, "request-headers", GST_TYPE_STRUCTURE,
1066       headers, NULL);
1067   gst_structure_free (headers);
1068   headers = gst_structure_new_empty ("response-headers");
1069   soup_message_headers_foreach (msg->response_headers, insert_http_header,
1070       headers);
1071   gst_structure_set (http_headers, "response-headers", GST_TYPE_STRUCTURE,
1072       headers, NULL);
1073   gst_structure_free (headers);
1074
1075   http_headers_event =
1076       gst_event_new_custom (GST_EVENT_CUSTOM_DOWNSTREAM_STICKY, http_headers);
1077   gst_event_replace (&src->http_headers_event, http_headers_event);
1078   gst_event_unref (http_headers_event);
1079
1080   /* Parse Content-Length. */
1081   if (soup_message_headers_get_encoding (msg->response_headers) ==
1082       SOUP_ENCODING_CONTENT_LENGTH) {
1083     newsize = src->request_position +
1084         soup_message_headers_get_content_length (msg->response_headers);
1085     if (!src->have_size || (src->content_size != newsize)) {
1086       src->content_size = newsize;
1087       src->have_size = TRUE;
1088       src->seekable = TRUE;
1089       GST_DEBUG_OBJECT (src, "size = %" G_GUINT64_FORMAT, src->content_size);
1090
1091       basesrc = GST_BASE_SRC_CAST (src);
1092       basesrc->segment.duration = src->content_size;
1093       gst_element_post_message (GST_ELEMENT (src),
1094           gst_message_new_duration_changed (GST_OBJECT (src)));
1095     }
1096   }
1097
1098   /* If the server reports Accept-Ranges: none we don't have to try
1099    * doing range requests at all
1100    */
1101   if ((accept_ranges =
1102           soup_message_headers_get_one (msg->response_headers,
1103               "Accept-Ranges"))) {
1104     if (g_ascii_strcasecmp (accept_ranges, "none") == 0)
1105       src->seekable = FALSE;
1106   }
1107
1108   /* Icecast stuff */
1109   tag_list = gst_tag_list_new_empty ();
1110
1111   if ((value =
1112           soup_message_headers_get_one (msg->response_headers,
1113               "icy-metaint")) != NULL) {
1114     gint icy_metaint = atoi (value);
1115
1116     GST_DEBUG_OBJECT (src, "icy-metaint: %s (parsed: %d)", value, icy_metaint);
1117     if (icy_metaint > 0) {
1118       if (src->src_caps)
1119         gst_caps_unref (src->src_caps);
1120
1121       src->src_caps = gst_caps_new_simple ("application/x-icy",
1122           "metadata-interval", G_TYPE_INT, icy_metaint, NULL);
1123
1124       gst_base_src_set_caps (GST_BASE_SRC (src), src->src_caps);
1125     }
1126   }
1127   if ((value =
1128           soup_message_headers_get_content_type (msg->response_headers,
1129               &params)) != NULL) {
1130     GST_DEBUG_OBJECT (src, "Content-Type: %s", value);
1131     if (g_ascii_strcasecmp (value, "audio/L16") == 0) {
1132       gint channels = 2;
1133       gint rate = 44100;
1134       char *param;
1135
1136       if (src->src_caps)
1137         gst_caps_unref (src->src_caps);
1138
1139       param = g_hash_table_lookup (params, "channels");
1140       if (param != NULL)
1141         channels = atol (param);
1142
1143       param = g_hash_table_lookup (params, "rate");
1144       if (param != NULL)
1145         rate = atol (param);
1146
1147       src->src_caps = gst_caps_new_simple ("audio/x-raw",
1148           "format", G_TYPE_STRING, "S16BE",
1149           "layout", G_TYPE_STRING, "interleaved",
1150           "channels", G_TYPE_INT, channels, "rate", G_TYPE_INT, rate, NULL);
1151
1152       gst_base_src_set_caps (GST_BASE_SRC (src), src->src_caps);
1153     } else {
1154       /* Set the Content-Type field on the caps */
1155       if (src->src_caps) {
1156         src->src_caps = gst_caps_make_writable (src->src_caps);
1157         gst_caps_set_simple (src->src_caps, "content-type", G_TYPE_STRING,
1158             value, NULL);
1159         gst_base_src_set_caps (GST_BASE_SRC (src), src->src_caps);
1160       }
1161     }
1162   }
1163
1164   if (params != NULL)
1165     g_hash_table_destroy (params);
1166
1167   if ((value =
1168           soup_message_headers_get_one (msg->response_headers,
1169               "icy-name")) != NULL) {
1170     g_free (src->iradio_name);
1171     src->iradio_name = gst_soup_http_src_unicodify (value);
1172     if (src->iradio_name) {
1173       gst_tag_list_add (tag_list, GST_TAG_MERGE_REPLACE, GST_TAG_ORGANIZATION,
1174           src->iradio_name, NULL);
1175     }
1176   }
1177   if ((value =
1178           soup_message_headers_get_one (msg->response_headers,
1179               "icy-genre")) != NULL) {
1180     g_free (src->iradio_genre);
1181     src->iradio_genre = gst_soup_http_src_unicodify (value);
1182     if (src->iradio_genre) {
1183       gst_tag_list_add (tag_list, GST_TAG_MERGE_REPLACE, GST_TAG_GENRE,
1184           src->iradio_genre, NULL);
1185     }
1186   }
1187   if ((value = soup_message_headers_get_one (msg->response_headers, "icy-url"))
1188       != NULL) {
1189     g_free (src->iradio_url);
1190     src->iradio_url = gst_soup_http_src_unicodify (value);
1191     if (src->iradio_url) {
1192       gst_tag_list_add (tag_list, GST_TAG_MERGE_REPLACE, GST_TAG_LOCATION,
1193           src->iradio_url, NULL);
1194     }
1195   }
1196   if (!gst_tag_list_is_empty (tag_list)) {
1197     GST_DEBUG_OBJECT (src,
1198         "calling gst_element_found_tags with %" GST_PTR_FORMAT, tag_list);
1199     gst_pad_push_event (GST_BASE_SRC_PAD (src), gst_event_new_tag (tag_list));
1200   } else {
1201     gst_tag_list_unref (tag_list);
1202   }
1203
1204   /* Handle HTTP errors. */
1205   gst_soup_http_src_parse_status (msg, src);
1206
1207   /* Check if Range header was respected. */
1208   if (src->ret == GST_FLOW_CUSTOM_ERROR &&
1209       src->read_position && msg->status_code != SOUP_STATUS_PARTIAL_CONTENT) {
1210     src->seekable = FALSE;
1211     GST_ELEMENT_ERROR (src, RESOURCE, SEEK,
1212         (_("Server does not support seeking.")),
1213         ("Server does not accept Range HTTP header, URL: %s, Redirect to: %s",
1214             src->location, GST_STR_NULL (src->redirection_uri)));
1215     src->ret = GST_FLOW_ERROR;
1216   }
1217
1218   /* If we are going to error out, stop all processing right here, so we
1219    * don't output any data (such as an error html page), and return
1220    * GST_FLOW_ERROR from the create function instead of having
1221    * got_chunk_cb overwrite src->ret with FLOW_OK again. */
1222   if (src->ret == GST_FLOW_ERROR || src->ret == GST_FLOW_EOS) {
1223   }
1224 }
1225
1226 static GstBuffer *
1227 gst_soup_http_src_alloc_buffer (GstSoupHTTPSrc * src)
1228 {
1229   GstBaseSrc *basesrc = GST_BASE_SRC_CAST (src);
1230   GstFlowReturn rc;
1231   GstBuffer *gstbuf;
1232
1233   rc = GST_BASE_SRC_CLASS (parent_class)->alloc (basesrc, -1,
1234       basesrc->blocksize, &gstbuf);
1235   if (G_UNLIKELY (rc != GST_FLOW_OK)) {
1236     return NULL;
1237   }
1238
1239   return gstbuf;
1240 }
1241
1242 #define SOUP_HTTP_SRC_ERROR(src,soup_msg,cat,code,error_message)     \
1243   GST_ELEMENT_ERROR ((src), cat, code, ("%s", error_message),        \
1244       ("%s (%d), URL: %s, Redirect to: %s", (soup_msg)->reason_phrase,                \
1245           (soup_msg)->status_code, (src)->location, GST_STR_NULL ((src)->redirection_uri)));
1246
1247 static void
1248 gst_soup_http_src_parse_status (SoupMessage * msg, GstSoupHTTPSrc * src)
1249 {
1250   if (msg->method == SOUP_METHOD_HEAD) {
1251     if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code))
1252       GST_DEBUG_OBJECT (src, "Ignoring error %d during HEAD request",
1253           msg->status_code);
1254   } else if (SOUP_STATUS_IS_TRANSPORT_ERROR (msg->status_code)) {
1255     switch (msg->status_code) {
1256       case SOUP_STATUS_CANT_RESOLVE:
1257       case SOUP_STATUS_CANT_RESOLVE_PROXY:
1258         SOUP_HTTP_SRC_ERROR (src, msg, RESOURCE, NOT_FOUND,
1259             _("Could not resolve server name."));
1260         src->ret = GST_FLOW_ERROR;
1261         break;
1262       case SOUP_STATUS_CANT_CONNECT:
1263       case SOUP_STATUS_CANT_CONNECT_PROXY:
1264         SOUP_HTTP_SRC_ERROR (src, msg, RESOURCE, OPEN_READ,
1265             _("Could not establish connection to server."));
1266         src->ret = GST_FLOW_ERROR;
1267         break;
1268       case SOUP_STATUS_SSL_FAILED:
1269         SOUP_HTTP_SRC_ERROR (src, msg, RESOURCE, OPEN_READ,
1270             _("Secure connection setup failed."));
1271         src->ret = GST_FLOW_ERROR;
1272         break;
1273       case SOUP_STATUS_IO_ERROR:
1274         if (src->max_retries == -1 || src->retry_count < src->max_retries) {
1275           src->ret = GST_FLOW_CUSTOM_ERROR;
1276         } else {
1277           SOUP_HTTP_SRC_ERROR (src, msg, RESOURCE, READ,
1278               _("A network error occurred, or the server closed the connection "
1279                   "unexpectedly."));
1280           src->ret = GST_FLOW_ERROR;
1281         }
1282         break;
1283       case SOUP_STATUS_MALFORMED:
1284         SOUP_HTTP_SRC_ERROR (src, msg, RESOURCE, READ,
1285             _("Server sent bad data."));
1286         src->ret = GST_FLOW_ERROR;
1287         break;
1288       case SOUP_STATUS_CANCELLED:
1289         /* No error message when interrupted by program. */
1290         break;
1291     }
1292   } else if (SOUP_STATUS_IS_CLIENT_ERROR (msg->status_code) ||
1293       SOUP_STATUS_IS_REDIRECTION (msg->status_code) ||
1294       SOUP_STATUS_IS_SERVER_ERROR (msg->status_code)) {
1295     /* Report HTTP error. */
1296
1297     /* when content_size is unknown and we have just finished receiving
1298      * a body message, requests that go beyond the content limits will result
1299      * in an error. Here we convert those to EOS */
1300     if (msg->status_code == SOUP_STATUS_REQUESTED_RANGE_NOT_SATISFIABLE &&
1301         src->have_body && !src->have_size) {
1302       GST_DEBUG_OBJECT (src, "Requested range out of limits and received full "
1303           "body, returning EOS");
1304       src->ret = GST_FLOW_EOS;
1305       return;
1306     }
1307
1308     /* FIXME: reason_phrase is not translated and not suitable for user
1309      * error dialog according to libsoup documentation.
1310      */
1311     if (msg->status_code == SOUP_STATUS_NOT_FOUND) {
1312       GST_ELEMENT_ERROR (src, RESOURCE, NOT_FOUND,
1313           ("%s", msg->reason_phrase),
1314           ("%s (%d), URL: %s, Redirect to: %s", msg->reason_phrase,
1315               msg->status_code, src->location,
1316               GST_STR_NULL (src->redirection_uri)));
1317     } else if (msg->status_code == SOUP_STATUS_UNAUTHORIZED
1318         || msg->status_code == SOUP_STATUS_PAYMENT_REQUIRED
1319         || msg->status_code == SOUP_STATUS_FORBIDDEN
1320         || msg->status_code == SOUP_STATUS_PROXY_AUTHENTICATION_REQUIRED) {
1321       GST_ELEMENT_ERROR (src, RESOURCE, NOT_AUTHORIZED, ("%s",
1322               msg->reason_phrase), ("%s (%d), URL: %s, Redirect to: %s",
1323               msg->reason_phrase, msg->status_code, src->location,
1324               GST_STR_NULL (src->redirection_uri)));
1325     } else {
1326       GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ,
1327           ("%s", msg->reason_phrase),
1328           ("%s (%d), URL: %s, Redirect to: %s", msg->reason_phrase,
1329               msg->status_code, src->location,
1330               GST_STR_NULL (src->redirection_uri)));
1331     }
1332     src->ret = GST_FLOW_ERROR;
1333   }
1334 }
1335
1336 static gboolean
1337 gst_soup_http_src_build_message (GstSoupHTTPSrc * src, const gchar * method)
1338 {
1339   g_return_val_if_fail (src->msg == NULL, FALSE);
1340
1341   src->msg = soup_message_new (method, src->location);
1342   if (!src->msg) {
1343     GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ,
1344         ("Error parsing URL."), ("URL: %s", src->location));
1345     return FALSE;
1346   }
1347   if (!src->keep_alive) {
1348     soup_message_headers_append (src->msg->request_headers, "Connection",
1349         "close");
1350   }
1351   if (src->iradio_mode) {
1352     soup_message_headers_append (src->msg->request_headers, "icy-metadata",
1353         "1");
1354   }
1355   if (src->cookies) {
1356     gchar **cookie;
1357
1358     for (cookie = src->cookies; *cookie != NULL; cookie++) {
1359       soup_message_headers_append (src->msg->request_headers, "Cookie",
1360           *cookie);
1361     }
1362   }
1363
1364   soup_message_set_flags (src->msg, SOUP_MESSAGE_OVERWRITE_CHUNKS |
1365       (src->automatic_redirect ? 0 : SOUP_MESSAGE_NO_REDIRECT));
1366   gst_soup_http_src_add_range_header (src, src->request_position,
1367       src->stop_position);
1368
1369   gst_soup_http_src_add_extra_headers (src);
1370
1371   return TRUE;
1372 }
1373
1374 static void
1375 gst_soup_http_src_check_input_stream_interfaces (GstSoupHTTPSrc * src)
1376 {
1377   if (!src->input_stream)
1378     return;
1379
1380   src->has_pollable_interface = G_IS_POLLABLE_INPUT_STREAM (src->input_stream)
1381       && g_pollable_input_stream_can_poll ((GPollableInputStream *)
1382       src->input_stream);
1383 }
1384
1385 static GstFlowReturn
1386 gst_soup_http_src_send_message (GstSoupHTTPSrc * src)
1387 {
1388   g_return_val_if_fail (src->msg != NULL, GST_FLOW_ERROR);
1389
1390   g_assert (src->input_stream == NULL);
1391   g_assert (src->poll_source == NULL);
1392
1393   /* FIXME We are ignoring the GError here, might be useful to debug */
1394   src->input_stream =
1395       soup_session_send (src->session, src->msg, src->cancellable, NULL);
1396   gst_soup_http_src_got_headers (src, src->msg);
1397   if (src->ret != GST_FLOW_OK) {
1398     return src->ret;
1399   }
1400
1401   if (!src->input_stream) {
1402     GST_DEBUG_OBJECT (src, "Didn't get an input stream");
1403     return GST_FLOW_ERROR;
1404   }
1405
1406   if (SOUP_STATUS_IS_SUCCESSFUL (src->msg->status_code)) {
1407     GST_DEBUG_OBJECT (src, "Successfully got a reply");
1408   } else {
1409     /* FIXME - be more helpful to people debugging */
1410     return GST_FLOW_ERROR;
1411   }
1412
1413   gst_soup_http_src_check_input_stream_interfaces (src);
1414
1415   return GST_FLOW_OK;
1416 }
1417
1418 static GstFlowReturn
1419 gst_soup_http_src_do_request (GstSoupHTTPSrc * src, const gchar * method)
1420 {
1421   if (src->max_retries != -1 && src->retry_count > src->max_retries) {
1422     GST_DEBUG_OBJECT (src, "Max retries reached");
1423     src->ret = GST_FLOW_ERROR;
1424     return src->ret;
1425   }
1426
1427   src->retry_count++;
1428   /* EOS immediately if we have an empty segment */
1429   if (src->request_position == src->stop_position)
1430     return GST_FLOW_EOS;
1431
1432   GST_LOG_OBJECT (src, "Running request for method: %s", method);
1433
1434   /* Update the position if we are retrying */
1435   if (src->msg && (src->request_position != src->read_position)) {
1436     gst_soup_http_src_add_range_header (src, src->request_position,
1437         src->stop_position);
1438   }
1439
1440   if (!src->msg) {
1441     if (!gst_soup_http_src_build_message (src, method)) {
1442       return GST_FLOW_ERROR;
1443     }
1444   }
1445
1446   if (g_cancellable_is_cancelled (src->cancellable)) {
1447     GST_INFO_OBJECT (src, "interrupted");
1448     src->ret = GST_FLOW_FLUSHING;
1449     goto done;
1450   }
1451   src->ret = gst_soup_http_src_send_message (src);
1452
1453 done:
1454   return src->ret;
1455 }
1456
1457 static void
1458 gst_soup_http_src_update_position (GstSoupHTTPSrc * src, gint64 bytes_read)
1459 {
1460   GstBaseSrc *basesrc = GST_BASE_SRC_CAST (src);
1461   guint64 new_position;
1462
1463   new_position = src->read_position + bytes_read;
1464   if (G_LIKELY (src->request_position == src->read_position))
1465     src->request_position = new_position;
1466   src->read_position = new_position;
1467
1468   if (src->have_size) {
1469     if (new_position > src->content_size) {
1470       GST_DEBUG_OBJECT (src, "Got position previous estimated content size "
1471           "(%" G_GINT64_FORMAT " > %" G_GINT64_FORMAT ")", new_position,
1472           src->content_size);
1473       src->content_size = new_position;
1474       basesrc->segment.duration = src->content_size;
1475       gst_element_post_message (GST_ELEMENT (src),
1476           gst_message_new_duration_changed (GST_OBJECT (src)));
1477     } else if (new_position == src->content_size) {
1478       GST_DEBUG_OBJECT (src, "We're EOS now");
1479     }
1480   }
1481 }
1482
1483 static gboolean
1484 _gst_soup_http_src_data_available_callback (GObject * pollable_stream,
1485     gpointer udata)
1486 {
1487   GstSoupHTTPSrc *src = udata;
1488
1489   src->have_data = TRUE;
1490   return TRUE;
1491 }
1492
1493 /* Need to wait on a gsource to know when data is available */
1494 static gboolean
1495 gst_soup_http_src_wait_for_data (GstSoupHTTPSrc * src)
1496 {
1497   src->have_data = FALSE;
1498
1499   if (!src->poll_source) {
1500     src->poll_source =
1501         g_pollable_input_stream_create_source ((GPollableInputStream *)
1502         src->input_stream, src->cancellable);
1503     g_source_set_callback (src->poll_source,
1504         (GSourceFunc) _gst_soup_http_src_data_available_callback, src, NULL);
1505     g_source_attach (src->poll_source, src->poll_context);
1506   }
1507
1508   while (!src->have_data && !g_cancellable_is_cancelled (src->cancellable)) {
1509     g_main_context_iteration (src->poll_context, TRUE);
1510   }
1511
1512   return src->have_data;
1513 }
1514
1515 static GstFlowReturn
1516 gst_soup_http_src_read_buffer (GstSoupHTTPSrc * src, GstBuffer ** outbuf)
1517 {
1518   gssize read_bytes;
1519   GstMapInfo mapinfo;
1520   GstBaseSrc *bsrc;
1521   GstFlowReturn ret;
1522   GError *err = NULL;
1523
1524   bsrc = GST_BASE_SRC_CAST (src);
1525
1526   *outbuf = gst_soup_http_src_alloc_buffer (src);
1527   if (!*outbuf) {
1528     GST_WARNING_OBJECT (src, "Failed to allocate buffer");
1529     return GST_FLOW_ERROR;
1530   }
1531
1532   if (!gst_buffer_map (*outbuf, &mapinfo, GST_MAP_WRITE)) {
1533     GST_WARNING_OBJECT (src, "Failed to map buffer");
1534     return GST_FLOW_ERROR;
1535   }
1536
1537   if (src->has_pollable_interface) {
1538     while (1) {
1539       read_bytes =
1540           g_pollable_input_stream_read_nonblocking ((GPollableInputStream *)
1541           src->input_stream, mapinfo.data, mapinfo.size, src->cancellable,
1542           &err);
1543       if (read_bytes == -1) {
1544         if (err && g_error_matches (err, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK)) {
1545           g_error_free (err);
1546           err = NULL;
1547
1548           /* no data yet, wait */
1549           if (gst_soup_http_src_wait_for_data (src))
1550             /* retry */
1551             continue;
1552         }
1553       }
1554       break;
1555     }
1556   } else {
1557     read_bytes =
1558         g_input_stream_read (src->input_stream, mapinfo.data, mapinfo.size,
1559         src->cancellable, NULL);
1560   }
1561
1562   if (err)
1563     g_error_free (err);
1564
1565   GST_DEBUG_OBJECT (src, "Read %" G_GSSIZE_FORMAT " bytes from http input",
1566       read_bytes);
1567
1568   g_mutex_lock (&src->mutex);
1569   if (g_cancellable_is_cancelled (src->cancellable)) {
1570     g_mutex_unlock (&src->mutex);
1571     return GST_FLOW_FLUSHING;
1572   }
1573   g_mutex_unlock (&src->mutex);
1574
1575   gst_buffer_unmap (*outbuf, &mapinfo);
1576   if (read_bytes > 0) {
1577     gst_buffer_set_size (*outbuf, read_bytes);
1578     GST_BUFFER_OFFSET (*outbuf) = bsrc->segment.position;
1579     ret = GST_FLOW_OK;
1580     gst_soup_http_src_update_position (src, read_bytes);
1581
1582     /* Got some data, reset retry counter */
1583     src->retry_count = 0;
1584   } else {
1585     gst_buffer_unref (*outbuf);
1586     if (read_bytes < 0) {
1587       /* Maybe the server disconnected, retry */
1588       ret = GST_FLOW_CUSTOM_ERROR;
1589     } else {
1590       ret = GST_FLOW_EOS;
1591       src->have_body = TRUE;
1592     }
1593   }
1594   return ret;
1595 }
1596
1597 static GstFlowReturn
1598 gst_soup_http_src_create (GstPushSrc * psrc, GstBuffer ** outbuf)
1599 {
1600   GstSoupHTTPSrc *src;
1601   GstFlowReturn ret = GST_FLOW_OK;
1602   GstEvent *http_headers_event = NULL;
1603
1604   src = GST_SOUP_HTTP_SRC (psrc);
1605
1606 retry:
1607   g_mutex_lock (&src->mutex);
1608
1609   /* Check for pending position change */
1610   if (src->request_position != src->read_position) {
1611     gst_soup_http_src_destroy_input_stream (src);
1612   }
1613
1614   if (g_cancellable_is_cancelled (src->cancellable)) {
1615     ret = GST_FLOW_FLUSHING;
1616     g_mutex_unlock (&src->mutex);
1617     goto done;
1618   }
1619
1620   /* If we have no open connection to the server, start one */
1621   if (!src->input_stream) {
1622     *outbuf = NULL;
1623     ret =
1624         gst_soup_http_src_do_request (src,
1625         src->method ? src->method : SOUP_METHOD_GET);
1626     http_headers_event = src->http_headers_event;
1627     src->http_headers_event = NULL;
1628   }
1629   g_mutex_unlock (&src->mutex);
1630
1631   if (ret == GST_FLOW_OK || ret == GST_FLOW_CUSTOM_ERROR) {
1632     if (http_headers_event) {
1633       gst_pad_push_event (GST_BASE_SRC_PAD (src), http_headers_event);
1634       http_headers_event = NULL;
1635     }
1636   }
1637
1638   if (ret == GST_FLOW_OK)
1639     ret = gst_soup_http_src_read_buffer (src, outbuf);
1640
1641 done:
1642   GST_DEBUG_OBJECT (src, "Returning %d %s", ret, gst_flow_get_name (ret));
1643   if (ret != GST_FLOW_OK) {
1644     if (http_headers_event)
1645       gst_event_unref (http_headers_event);
1646
1647     g_mutex_lock (&src->mutex);
1648     gst_soup_http_src_destroy_input_stream (src);
1649     g_mutex_unlock (&src->mutex);
1650     if (ret == GST_FLOW_CUSTOM_ERROR)
1651       goto retry;
1652   }
1653   return ret;
1654 }
1655
1656 static gboolean
1657 gst_soup_http_src_start (GstBaseSrc * bsrc)
1658 {
1659   GstSoupHTTPSrc *src = GST_SOUP_HTTP_SRC (bsrc);
1660
1661   GST_DEBUG_OBJECT (src, "start(\"%s\")", src->location);
1662
1663   return gst_soup_http_src_session_open (src);
1664 }
1665
1666 static gboolean
1667 gst_soup_http_src_stop (GstBaseSrc * bsrc)
1668 {
1669   GstSoupHTTPSrc *src;
1670
1671   src = GST_SOUP_HTTP_SRC (bsrc);
1672   GST_DEBUG_OBJECT (src, "stop()");
1673   if (src->keep_alive && !src->msg)
1674     gst_soup_http_src_cancel_message (src);
1675   else
1676     gst_soup_http_src_session_close (src);
1677
1678   gst_soup_http_src_reset (src);
1679   return TRUE;
1680 }
1681
1682 static GstStateChangeReturn
1683 gst_soup_http_src_change_state (GstElement * element, GstStateChange transition)
1684 {
1685   GstStateChangeReturn ret;
1686   GstSoupHTTPSrc *src;
1687
1688   src = GST_SOUP_HTTP_SRC (element);
1689
1690   switch (transition) {
1691     case GST_STATE_CHANGE_READY_TO_NULL:
1692       gst_soup_http_src_session_close (src);
1693       break;
1694     default:
1695       break;
1696   }
1697
1698   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
1699
1700   return ret;
1701 }
1702
1703 /* Interrupt a blocking request. */
1704 static gboolean
1705 gst_soup_http_src_unlock (GstBaseSrc * bsrc)
1706 {
1707   GstSoupHTTPSrc *src;
1708
1709   src = GST_SOUP_HTTP_SRC (bsrc);
1710   GST_DEBUG_OBJECT (src, "unlock()");
1711
1712   src->ret = GST_FLOW_FLUSHING;
1713   gst_soup_http_src_cancel_message (src);
1714   return TRUE;
1715 }
1716
1717 /* Interrupt interrupt. */
1718 static gboolean
1719 gst_soup_http_src_unlock_stop (GstBaseSrc * bsrc)
1720 {
1721   GstSoupHTTPSrc *src;
1722
1723   src = GST_SOUP_HTTP_SRC (bsrc);
1724   GST_DEBUG_OBJECT (src, "unlock_stop()");
1725
1726   src->ret = GST_FLOW_OK;
1727   g_cancellable_reset (src->cancellable);
1728   return TRUE;
1729 }
1730
1731 static gboolean
1732 gst_soup_http_src_get_size (GstBaseSrc * bsrc, guint64 * size)
1733 {
1734   GstSoupHTTPSrc *src;
1735
1736   src = GST_SOUP_HTTP_SRC (bsrc);
1737
1738   if (src->have_size) {
1739     GST_DEBUG_OBJECT (src, "get_size() = %" G_GUINT64_FORMAT,
1740         src->content_size);
1741     *size = src->content_size;
1742     return TRUE;
1743   }
1744   GST_DEBUG_OBJECT (src, "get_size() = FALSE");
1745   return FALSE;
1746 }
1747
1748 static void
1749 gst_soup_http_src_check_seekable (GstSoupHTTPSrc * src)
1750 {
1751   GstFlowReturn ret = GST_FLOW_OK;
1752
1753   /* Special case to check if the server allows range requests
1754    * before really starting to get data in the buffer creation
1755    * loops.
1756    */
1757   if (!src->got_headers && GST_STATE (src) >= GST_STATE_PAUSED) {
1758     g_mutex_lock (&src->mutex);
1759     while (!src->got_headers && !g_cancellable_is_cancelled (src->cancellable)
1760         && ret == GST_FLOW_OK) {
1761       if ((src->msg && src->msg->method != SOUP_METHOD_HEAD)) {
1762         /* wait for the current request to finish */
1763         g_cond_wait (&src->have_headers_cond, &src->mutex);
1764       } else {
1765         if (gst_soup_http_src_session_open (src)) {
1766           ret = gst_soup_http_src_do_request (src, SOUP_METHOD_HEAD);
1767         }
1768       }
1769     }
1770     if (src->ret == GST_FLOW_EOS) {
1771       /* A HEAD request shouldn't lead to EOS */
1772       src->ret = GST_FLOW_OK;
1773     }
1774     g_mutex_unlock (&src->mutex);
1775   }
1776 }
1777
1778 static gboolean
1779 gst_soup_http_src_is_seekable (GstBaseSrc * bsrc)
1780 {
1781   GstSoupHTTPSrc *src = GST_SOUP_HTTP_SRC (bsrc);
1782
1783   gst_soup_http_src_check_seekable (src);
1784
1785   return src->seekable;
1786 }
1787
1788 static gboolean
1789 gst_soup_http_src_do_seek (GstBaseSrc * bsrc, GstSegment * segment)
1790 {
1791   GstSoupHTTPSrc *src = GST_SOUP_HTTP_SRC (bsrc);
1792
1793   GST_DEBUG_OBJECT (src, "do_seek(%" G_GUINT64_FORMAT "-%" G_GUINT64_FORMAT
1794       ")", segment->start, segment->stop);
1795   if (src->read_position == segment->start &&
1796       src->request_position == src->read_position &&
1797       src->stop_position == segment->stop) {
1798     GST_DEBUG_OBJECT (src,
1799         "Seek to current read/end position and no seek pending");
1800     return TRUE;
1801   }
1802
1803   gst_soup_http_src_check_seekable (src);
1804
1805   /* If we have no headers we don't know yet if it is seekable or not.
1806    * Store the start position and error out later if it isn't */
1807   if (src->got_headers && !src->seekable) {
1808     GST_WARNING_OBJECT (src, "Not seekable");
1809     return FALSE;
1810   }
1811
1812   if (segment->rate < 0.0 || segment->format != GST_FORMAT_BYTES) {
1813     GST_WARNING_OBJECT (src, "Invalid seek segment");
1814     return FALSE;
1815   }
1816
1817   if (src->have_size && segment->start >= src->content_size) {
1818     GST_WARNING_OBJECT (src,
1819         "Potentially seeking behind end of file, might EOS immediately");
1820   }
1821
1822   /* Wait for create() to handle the jump in offset. */
1823   src->request_position = segment->start;
1824   src->stop_position = segment->stop;
1825
1826   return TRUE;
1827 }
1828
1829 static gboolean
1830 gst_soup_http_src_query (GstBaseSrc * bsrc, GstQuery * query)
1831 {
1832   GstSoupHTTPSrc *src = GST_SOUP_HTTP_SRC (bsrc);
1833   gboolean ret;
1834   GstSchedulingFlags flags;
1835   gint minsize, maxsize, align;
1836
1837   switch (GST_QUERY_TYPE (query)) {
1838     case GST_QUERY_URI:
1839       gst_query_set_uri (query, src->location);
1840       if (src->redirection_uri != NULL) {
1841         gst_query_set_uri_redirection (query, src->redirection_uri);
1842         gst_query_set_uri_redirection_permanent (query,
1843             src->redirection_permanent);
1844       }
1845       ret = TRUE;
1846       break;
1847     default:
1848       ret = FALSE;
1849       break;
1850   }
1851
1852   if (!ret)
1853     ret = GST_BASE_SRC_CLASS (parent_class)->query (bsrc, query);
1854
1855   switch (GST_QUERY_TYPE (query)) {
1856     case GST_QUERY_SCHEDULING:
1857       gst_query_parse_scheduling (query, &flags, &minsize, &maxsize, &align);
1858       flags |= GST_SCHEDULING_FLAG_BANDWIDTH_LIMITED;
1859       gst_query_set_scheduling (query, flags, minsize, maxsize, align);
1860       break;
1861     default:
1862       break;
1863   }
1864
1865   return ret;
1866 }
1867
1868 static gboolean
1869 gst_soup_http_src_set_location (GstSoupHTTPSrc * src, const gchar * uri,
1870     GError ** error)
1871 {
1872   const char *alt_schemes[] = { "icy://", "icyx://" };
1873   guint i;
1874
1875   if (src->location) {
1876     g_free (src->location);
1877     src->location = NULL;
1878   }
1879
1880   if (uri == NULL)
1881     return FALSE;
1882
1883   for (i = 0; i < G_N_ELEMENTS (alt_schemes); i++) {
1884     if (g_str_has_prefix (uri, alt_schemes[i])) {
1885       src->location =
1886           g_strdup_printf ("http://%s", uri + strlen (alt_schemes[i]));
1887       return TRUE;
1888     }
1889   }
1890
1891   if (src->redirection_uri) {
1892     g_free (src->redirection_uri);
1893     src->redirection_uri = NULL;
1894   }
1895
1896   src->location = g_strdup (uri);
1897
1898   return TRUE;
1899 }
1900
1901 static gboolean
1902 gst_soup_http_src_set_proxy (GstSoupHTTPSrc * src, const gchar * uri)
1903 {
1904   if (src->proxy) {
1905     soup_uri_free (src->proxy);
1906     src->proxy = NULL;
1907   }
1908
1909   if (uri == NULL || *uri == '\0')
1910     return TRUE;
1911
1912   if (g_str_has_prefix (uri, "http://")) {
1913     src->proxy = soup_uri_new (uri);
1914   } else {
1915     gchar *new_uri = g_strconcat ("http://", uri, NULL);
1916
1917     src->proxy = soup_uri_new (new_uri);
1918     g_free (new_uri);
1919   }
1920
1921   return (src->proxy != NULL);
1922 }
1923
1924 static guint
1925 gst_soup_http_src_uri_get_type (GType type)
1926 {
1927   return GST_URI_SRC;
1928 }
1929
1930 static const gchar *const *
1931 gst_soup_http_src_uri_get_protocols (GType type)
1932 {
1933   static const gchar *protocols[] = { "http", "https", "icy", "icyx", NULL };
1934
1935   return protocols;
1936 }
1937
1938 static gchar *
1939 gst_soup_http_src_uri_get_uri (GstURIHandler * handler)
1940 {
1941   GstSoupHTTPSrc *src = GST_SOUP_HTTP_SRC (handler);
1942
1943   /* FIXME: make thread-safe */
1944   return g_strdup (src->location);
1945 }
1946
1947 static gboolean
1948 gst_soup_http_src_uri_set_uri (GstURIHandler * handler, const gchar * uri,
1949     GError ** error)
1950 {
1951   GstSoupHTTPSrc *src = GST_SOUP_HTTP_SRC (handler);
1952
1953   return gst_soup_http_src_set_location (src, uri, error);
1954 }
1955
1956 static void
1957 gst_soup_http_src_uri_handler_init (gpointer g_iface, gpointer iface_data)
1958 {
1959   GstURIHandlerInterface *iface = (GstURIHandlerInterface *) g_iface;
1960
1961   iface->get_type = gst_soup_http_src_uri_get_type;
1962   iface->get_protocols = gst_soup_http_src_uri_get_protocols;
1963   iface->get_uri = gst_soup_http_src_uri_get_uri;
1964   iface->set_uri = gst_soup_http_src_uri_set_uri;
1965 }