int proxied_session_server(ne_session **sess, const char *scheme,
const char *host, unsigned int fakeport,
server_fn fn, void *userdata)
{
unsigned int port;
CALL(new_spawn_server(1, fn, userdata, &port));
*sess = ne_session_create(scheme, host, fakeport);
ne_session_proxy(*sess, "localhost", port);
return OK;
}
/* Configure the proxy depending on the variables */
static int configureProxy( ne_session *session )
{
int port = 8080;
int re = -1;
if( ! session ) return -1;
if( ! dav_session.proxy_type ) return 0; /* Go by NoProxy per default */
if( dav_session.proxy_port > 0 ) {
port = dav_session.proxy_port;
}
if( c_streq(dav_session.proxy_type, "NoProxy" )) {
DEBUG_WEBDAV("No proxy configured.");
re = 0;
} else if( c_streq(dav_session.proxy_type, "DefaultProxy") ||
c_streq(dav_session.proxy_type, "HttpProxy") ||
c_streq(dav_session.proxy_type, "HttpCachingProxy") ||
c_streq(dav_session.proxy_type, "Socks5Proxy")) {
if( dav_session.proxy_host ) {
DEBUG_WEBDAV("%s at %s:%d", dav_session.proxy_type, dav_session.proxy_host, port );
if (c_streq(dav_session.proxy_type, "Socks5Proxy")) {
ne_session_socks_proxy(session, NE_SOCK_SOCKSV5, dav_session.proxy_host, port,
dav_session.proxy_user, dav_session.proxy_pwd);
} else {
ne_session_proxy(session, dav_session.proxy_host, port );
}
re = 2;
} else {
DEBUG_WEBDAV("%s requested but no proxy host defined.", dav_session.proxy_type );
/* we used to try ne_system_session_proxy here, but we should rather err out
to behave exactly like the caller. */
}
} else {
DEBUG_WEBDAV( "Unsupported Proxy: %s", dav_session.proxy_type );
}
return re;
}
static int init_session(ne_session *sess)
{
if (proxy_hostname) {
ne_session_proxy(sess, proxy_hostname, proxy_port);
}
ne_set_useragent(i_session, "davtest/" PACKAGE_VERSION);
if (i_username) {
ne_set_server_auth(sess, auth, NULL);
}
if (use_secure) {
if (!ne_supports_ssl()) {
t_context("No SSL support, reconfigure using --with-ssl");
return FAILHARD;
} else {
ne_ssl_set_verify(sess, ignore_verify, NULL);
}
}
return OK;
}
static int open_handle (struct neon_handle * handle, uint64_t startbyte)
{
int ret;
char * proxy_host = NULL;
int proxy_port = 0;
bool_t use_proxy = aud_get_bool (NULL, "use_proxy");
bool_t use_proxy_auth = aud_get_bool (NULL, "use_proxy_auth");
if (use_proxy)
{
proxy_host = aud_get_str (NULL, "proxy_host");
proxy_port = aud_get_int (NULL, "proxy_port");
}
handle->redircount = 0;
_DEBUG ("<%p> Parsing URL", handle);
if (ne_uri_parse (handle->url, handle->purl) != 0)
{
_ERROR ("<%p> Could not parse URL '%s'", (void *) handle, handle->url);
return -1;
}
while (handle->redircount < 10)
{
if (! handle->purl->port)
handle->purl->port = ne_uri_defaultport (handle->purl->scheme);
_DEBUG ("<%p> Creating session to %s://%s:%d", handle,
handle->purl->scheme, handle->purl->host, handle->purl->port);
handle->session = ne_session_create (handle->purl->scheme,
handle->purl->host, handle->purl->port);
ne_redirect_register (handle->session);
ne_add_server_auth (handle->session, NE_AUTH_BASIC, server_auth_callback, (void *) handle);
ne_set_session_flag (handle->session, NE_SESSFLAG_ICYPROTO, 1);
ne_set_session_flag (handle->session, NE_SESSFLAG_PERSIST, 0);
#ifdef HAVE_NE_SET_CONNECT_TIMEOUT
ne_set_connect_timeout (handle->session, 10);
#endif
ne_set_read_timeout (handle->session, 10);
ne_set_useragent (handle->session, "Audacious/" PACKAGE_VERSION);
if (use_proxy)
{
_DEBUG ("<%p> Using proxy: %s:%d", handle, proxy_host, proxy_port);
ne_session_proxy (handle->session, proxy_host, proxy_port);
if (use_proxy_auth)
{
_DEBUG ("<%p> Using proxy authentication", handle);
ne_add_proxy_auth (handle->session, NE_AUTH_BASIC,
neon_proxy_auth_cb, (void *) handle);
}
}
if (! strcmp ("https", handle->purl->scheme))
{
ne_ssl_trust_default_ca (handle->session);
ne_ssl_set_verify (handle->session,
neon_vfs_verify_environment_ssl_certs, handle->session);
}
_DEBUG ("<%p> Creating request", handle);
ret = open_request (handle, startbyte);
if (! ret)
{
str_unref (proxy_host);
return 0;
}
if (ret == -1)
{
ne_session_destroy (handle->session);
handle->session = NULL;
str_unref (proxy_host);
return -1;
}
_DEBUG ("<%p> Following redirect...", handle);
ne_session_destroy (handle->session);
handle->session = NULL;
}
/* If we get here, our redirect count exceeded */
_ERROR ("<%p> Redirect count exceeded for URL %s", (void *) handle, handle->url);
str_unref (proxy_host);
return 1;
}
/* FIXME: Leaky as a bucket */
void open_connection(const char *url)
{
char *proxy_host = get_option(opt_proxy), *pnt;
ne_server_capabilities caps;
int ret, use_ssl = 0;
ne_session *sess;
if (session.connected) {
close_connection();
} else {
ne_uri_free(&session.uri);
if (session.lastwp) {
ne_free(session.lastwp);
session.lastwp = NULL;
}
}
/* Single argument: see whether we have a path or scheme */
if (strchr(url, '/') == NULL) {
/* No path, no scheme -> just a hostname */
pnt = strchr(url, ':');
if (pnt != NULL) {
*pnt++ = '\0';
session.uri.port = atoi(pnt);
} else {
session.uri.port = 80;
}
session.uri.host = ne_strdup(url);
session.uri.scheme = ne_strdup("http");
} else {
/* Parse the URL */
if (ne_uri_parse(url, &session.uri) || session.uri.host == NULL) {
printf(_("Could not parse URL `%s'\n"), url);
return;
}
if (session.uri.scheme == NULL)
session.uri.scheme = ne_strdup("http");
if (!session.uri.port)
session.uri.port = ne_uri_defaultport(session.uri.scheme);
if (strcasecmp(session.uri.scheme, "https") == 0) {
if (!ne_has_support(NE_FEATURE_SSL)) {
printf(_("SSL is not enabled.\n"));
return;
}
use_ssl = 1;
}
}
session.sess = ne_session_create(session.uri.scheme, session.uri.host,
session.uri.port);
sess = session.sess;
if (use_ssl && setup_ssl()) {
return;
}
ne_lockstore_register(session.locks, sess);
ne_redirect_register(sess);
ne_set_notifier(sess, notifier, NULL);
if (session.uri.path == NULL) {
session.uri.path = ne_strdup("/");
} else {
if (!ne_path_has_trailing_slash(session.uri.path)) {
pnt = ne_concat(session.uri.path, "/", NULL);
free(session.uri.path);
session.uri.path = pnt;
}
}
/* Get the proxy details */
if (proxy_host != NULL) {
if (get_option(opt_proxy_port) != NULL) {
proxy_port = atoi(get_option(opt_proxy_port));
} else {
proxy_port = 8080;
}
proxy_hostname = proxy_host;
}
#ifdef ENABLE_NETRC
{
netrc_entry *found;
found = search_netrc(netrc_list, session.uri.host);
if (found != NULL) {
if (found->account && found->password) {
server_username = found->account;
server_password = found->password;
}
}
}
#endif /* ENABLE_NETRC */
#ifdef NE_SESSFLAG_EXPECT100
ne_set_session_flag(session.sess, NE_SESSFLAG_EXPECT100, get_bool_option(opt_expect100));
#endif /* NE_SESSFLAG_EXPECT100 */
session.connected = 0;
ne_set_useragent(session.sess, "cadaver/" PACKAGE_VERSION);
ne_set_server_auth(session.sess, supply_creds_server, NULL);
ne_set_proxy_auth(session.sess, supply_creds_proxy, NULL);
if (proxy_host) {
ne_session_proxy(session.sess, proxy_hostname, proxy_port);
}
ret = ne_options(session.sess, session.uri.path, &caps);
switch (ret) {
case NE_OK:
session.connected = true;
if (set_path(session.uri.path)) {
close_connection();
}
break;
case NE_CONNECT:
if (proxy_host) {
printf(_("Could not connect to `%s' on port %d:\n%s\n"),
proxy_hostname, proxy_port, ne_get_error(session.sess));
} else {
printf(_("Could not connect to `%s' on port %d:\n%s\n"),
session.uri.host, session.uri.port, ne_get_error(session.sess));
}
break;
case NE_LOOKUP:
puts(ne_get_error(session.sess));
break;
default:
printf(_("Could not open collection:\n%s\n"),
ne_get_error(session.sess));
break;
}
}
/* Try to send the HTTP request to the Icecast server, and if possible deals with
* all the probable redirections (HTTP status code == 3xx)
*/
static gint
gst_neonhttp_src_send_request_and_redirect (GstNeonhttpSrc * src,
ne_session ** ses, ne_request ** req, gint64 offset, gboolean do_redir)
{
ne_session *session = NULL;
ne_request *request = NULL;
gchar **c;
gint res;
gint http_status = 0;
guint request_count = 0;
do {
if (src->proxy.host && src->proxy.port) {
session =
ne_session_create (src->uri.scheme, src->uri.host, src->uri.port);
ne_session_proxy (session, src->proxy.host, src->proxy.port);
} else if (src->proxy.host || src->proxy.port) {
/* both proxy host and port must be specified or none */
return HTTP_REQUEST_WRONG_PROXY;
} else {
session =
ne_session_create (src->uri.scheme, src->uri.host, src->uri.port);
}
if (src->connect_timeout > 0) {
ne_set_connect_timeout (session, src->connect_timeout);
}
if (src->read_timeout > 0) {
ne_set_read_timeout (session, src->read_timeout);
}
ne_set_session_flag (session, NE_SESSFLAG_ICYPROTO, 1);
ne_ssl_set_verify (session, ssl_verify_callback, src);
request = ne_request_create (session, "GET", src->query_string);
if (src->user_agent) {
ne_add_request_header (request, "User-Agent", src->user_agent);
}
for (c = src->cookies; c != NULL && *c != NULL; ++c) {
GST_INFO ("Adding header Cookie : %s", *c);
ne_add_request_header (request, "Cookies", *c);
}
if (src->iradio_mode)
ne_add_request_header (request, "icy-metadata", "1");
if (offset > 0) {
ne_print_request_header (request, "Range",
"bytes=%" G_GINT64_FORMAT "-", offset);
}
res = ne_begin_request (request);
if (res == NE_OK) {
/* When the HTTP status code is 3xx, it is not the SHOUTcast streaming content yet;
* Reload the HTTP request with a new URI value */
http_status = ne_get_status (request)->code;
if (STATUS_IS_REDIRECTION (http_status) && do_redir) {
const gchar *redir;
/* the new URI value to go when redirecting can be found on the 'Location' HTTP header */
redir = ne_get_response_header (request, "Location");
if (redir != NULL) {
ne_uri_free (&src->uri);
gst_neonhttp_src_set_location (src, redir, NULL);
GST_LOG_OBJECT (src, "Got HTTP Status Code %d", http_status);
GST_LOG_OBJECT (src, "Using 'Location' header [%s]", src->uri.host);
}
}
}
if ((res != NE_OK) ||
(offset == 0 && http_status != 200) ||
(offset > 0 && http_status != 206 &&
!STATUS_IS_REDIRECTION (http_status))) {
ne_request_destroy (request);
request = NULL;
ne_close_connection (session);
ne_session_destroy (session);
session = NULL;
if (offset > 0 && http_status != 206 &&
!STATUS_IS_REDIRECTION (http_status)) {
src->seekable = FALSE;
}
}
/* if - NE_OK */
if (STATUS_IS_REDIRECTION (http_status) && do_redir) {
++request_count;
GST_LOG_OBJECT (src, "redirect request_count is now %d", request_count);
if (request_count < MAX_HTTP_REDIRECTS_NUMBER && do_redir) {
GST_INFO_OBJECT (src, "Redirecting to %s", src->uri.host);
} else {
GST_WARNING_OBJECT (src, "Will not redirect, try again with a "
"different URI or redirect location %s", src->uri.host);
}
/* FIXME: when not redirecting automatically, shouldn't we post a
* redirect element message on the bus? */
}
/* do the redirect, go back to send another HTTP request now using the 'Location' */
} while (do_redir && (request_count < MAX_HTTP_REDIRECTS_NUMBER)
&& STATUS_IS_REDIRECTION (http_status));
if (session) {
*ses = session;
*req = request;
}
return res;
}