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