seal 0.1.0

data/mpg123/src/getlopt.h

@@ -0,0 +1,77 @@
+/*
+	getlopt: command line option/parameter parsing
+
+	copyright ?-2006 by the mpg123 project - free software under the terms of the LGPL 2.1
+	see COPYING and AUTHORS files in distribution or http://mpg123.org
+	initially written Oliver Fromme
+	old timestamp: Tue Apr  8 07:13:39 MET DST 1997
+*/
+
+#include <stdlib.h>
+#include <string.h>
+
+
+#ifndef _MPG123_GETLOPT_H_
+#define _MPG123_GETLOPT_H_
+
+extern int loptind;	/* index in argv[] */
+extern int loptchr;	/* index in argv[loptind] */
+extern char *loptarg;	/* points to argument if present, else to option */
+
+typedef struct {
+	char sname;	/* short option name, can be 0 */
+	char *lname;	/* long option name, can be 0 */
+	int flags;	/* see below */
+	void (*func)(char *);	/* called if != 0 (after setting of var) */
+	void *var;	/* type is *long, *char or **char, see below */
+	long value;
+} topt;
+
+/* ThOr: make this clear; distict long from int (since this is != on my Alpha) and really use a flag for every case (spare the 0 case 
+for .... no flag) */
+#define GLO_ARG  1
+#define GLO_CHAR 2
+#define GLO_INT  4
+#define GLO_LONG 8
+#define GLO_DOUBLE 16
+
+/* flags:
+ *	bit 0 = 0 - no argument
+ *		if var != NULL
+ *			*var := value or (char)value [see bit 1]
+ *		else
+ *			loptarg = &option
+ *			return ((value != 0) ? value : sname)
+ *	bit 0 = 1 - argument required
+ *		if var != NULL
+ *			*var := atoi(arg) or strdup(arg) [see bit 1]
+ *		else
+ *			loptarg = &arg
+ *			return ((value != 0) ? value : sname)
+ *
+ *	bit 1 = 1 - var is a pointer to a char (or string),
+ *			and value is interpreted as char
+ *	bit 2 = 1 - var is a pointer to int
+ *	bit 3 = 1 - var is a pointer to long
+ *
+ * Note: The options definition is terminated by a topt
+ *	 containing only zeroes.
+ */
+
+#define GLO_END		0
+#define GLO_UNKNOWN	-1
+#define GLO_NOARG	-2
+#define GLO_CONTINUE	-3
+
+int getlopt (int argc, char *argv[], topt *opts);
+
+/* return values:
+ *	GLO_END		(0)	end of options
+ *	GLO_UNKNOWN	(-1)	unknown option *loptarg
+ *	GLO_NOARG	(-2)	missing argument
+ *	GLO_CONTINUE	(-3)	(reserved for internal use)
+ *	else - return value according to flags (see above)
+ */
+
+
+#endif

data/mpg123/src/httpget.c

@@ -0,0 +1,700 @@
+/*
+	httpget.c: http communication
+
+	copyright ?-2011 by the mpg123 project - free software under the terms of the LGPL 2.1
+	see COPYING and AUTHORS files in distribution or http://mpg123.org
+	initially written Oliver Fromme
+	old timestamp: Wed Apr  9 20:57:47 MET DST 1997
+
+	Thomas' notes:
+	
+	I used to do 
+	GET http://server/path HTTP/1.0
+
+	But RFC 1945 says: The absoluteURI form is only allowed when the request is being made to a proxy.
+
+	so I should not do that. Since name based virtual hosts need the hostname in the request, I still need to provide that info.
+	Enter HTTP/1.1... there is a Host eader field to use (that mpg123 supposedly has used since some time anyway - but did it really work with my vhost test server)?
+	Now
+	GET /path/bla HTTP/1.1\r\nHost: host[:port]
+	Should work, but as a funny sidenote:
+	
+	RFC2616: To allow for transition to absoluteURIs in all requests in future versions of HTTP, all HTTP/1.1 servers MUST accept the absoluteURI form in requests, even though HTTP/1.1 clients will only generate them in requests to proxies.
+	
+	I was already full-on HTTP/1.1 as I recognized that mpg123 then would have to accept the chunked transfer encoding.
+	That is not desireable for its purpose... maybe when interleaving of shoutcasts with metadata chunks is supported, we can upgrade to 1.1.
+	Funny aspect there is that shoutcast servers do not do HTTP/1.1 chunked transfer but implement some different chunking themselves...
+*/
+
+#include "mpg123app.h"
+#include "httpget.h"
+
+#ifdef NETWORK
+#include "resolver.h"
+
+#include <errno.h>
+#include "true.h"
+#endif
+
+#include "debug.h"
+
+void httpdata_init(struct httpdata *e)
+{
+	mpg123_init_string(&e->content_type);
+	mpg123_init_string(&e->icy_url);
+	mpg123_init_string(&e->icy_name);
+	e->icy_interval = 0;
+	e->proxystate = PROXY_UNKNOWN;
+	mpg123_init_string(&e->proxyhost);
+	mpg123_init_string(&e->proxyport);
+}
+
+void httpdata_reset(struct httpdata *e)
+{
+	mpg123_free_string(&e->content_type);
+	mpg123_free_string(&e->icy_url);
+	mpg123_free_string(&e->icy_name);
+	e->icy_interval = 0;
+	/* the other stuff shall persist */
+}
+
+void httpdata_free(struct httpdata *e)
+{
+	httpdata_reset(e);
+	mpg123_free_string(&e->proxyhost);
+	mpg123_free_string(&e->proxyport);
+}
+
+/* mime type classes */
+#define M_FILE 0
+#define M_M3U  1
+#define M_PLS  2
+static const char* mime_file[] =
+{
+	"audio/mpeg",  "audio/x-mpeg",
+	"audio/mp3",   "audio/x-mp3", 
+	"audio/mpeg3", "audio/x-mpeg3",
+	"audio/mpg",   "audio/x-mpg",
+	"audio/x-mpegaudio",
+	"application/octet-stream", /* Assume raw binary data is some MPEG data. */
+	NULL
+};
+static const char* mime_m3u[] = { "audio/mpegurl", "audio/mpeg-url", "audio/x-mpegurl", NULL };
+static const char* mime_pls[]	= { "audio/x-scpls", "audio/scpls", "application/pls", NULL };
+static const char** mimes[] = { mime_file, mime_m3u, mime_pls, NULL };
+
+int debunk_mime(const char* mime)
+{
+	int i,j;
+	size_t len;
+	int r = 0;
+	char *aux;
+	/* Watch out for such: "audio/x-mpegurl; charset=utf-8" */
+	aux = strchr(mime, ';');
+	if(aux != NULL)
+	{
+		fprintf(stderr, "Warning: additional info in content-type ignored (%s)\n", aux+1);
+		/* Just compare up to before the ";". */
+		len = aux-mime;
+	}
+	/* Else, compare the whole string -- including the end. */
+	else len = strlen(mime)+1;
+
+	for(i=0; mimes[i]    != NULL; ++i)
+	for(j=0; mimes[i][j] != NULL; ++j)
+	if(!strncasecmp(mimes[i][j], mime, len)) goto debunk_result;
+
+debunk_result:
+	if(mimes[i] != NULL)
+	{
+		switch(i)
+		{
+			case M_FILE: r = IS_FILE;        break;
+			case M_M3U:  r = IS_LIST|IS_M3U; break;
+			case M_PLS:  r = IS_LIST|IS_PLS; break;
+			default: error("unexpected MIME debunk result -- coding error?!");
+		}
+	}
+	return r;
+}
+
+
+#ifdef NETWORK
+#if !defined (WANT_WIN32_SOCKETS)
+static int writestring (int fd, mpg123_string *string)
+{
+	size_t result, bytes;
+	char *ptr = string->p;
+	bytes = string->fill ? string->fill-1 : 0;
+
+	while(bytes)
+	{
+		result = write(fd, ptr, bytes);
+		if(result < 0 && errno != EINTR)
+		{
+			perror ("writing http string");
+			return FALSE;
+		}
+		else if(result == 0)
+		{
+			error("write: socket closed unexpectedly");
+			return FALSE;
+		}
+		ptr   += result;
+		bytes -= result;
+	}
+	return TRUE;
+}
+
+static size_t readstring (mpg123_string *string, size_t maxlen, FILE *f)
+{
+	int err;
+	debug2("Attempting readstring on %d for %"SIZE_P" bytes", f ? fileno(f) : 0, (size_p)maxlen);
+	string->fill = 0;
+	while(maxlen == 0 || string->fill < maxlen)
+	{
+		if(string->size-string->fill < 1)
+		if(!mpg123_grow_string(string, string->fill+4096))
+		{
+			error("Cannot allocate memory for reading.");
+			string->fill = 0;
+			return 0;
+		}
+		err = read(fileno(f),string->p+string->fill,1);
+		/* Whoa... reading one byte at a time... one could ensure the line break in another way, but more work. */
+		if( err == 1)
+		{
+			string->fill++;
+			if(string->p[string->fill-1] == '\n') break;
+		}
+		else if(errno != EINTR)
+		{
+			error("Error reading from socket or unexpected EOF.");
+			string->fill = 0;
+			/* bail out to prevent endless loop */
+			return 0;
+		}
+	}
+
+	if(!mpg123_grow_string(string, string->fill+1))
+	{
+		string->fill=0;
+	}
+	else
+	{
+		string->p[string->fill] = 0;
+		string->fill++;
+	}
+	return string->fill;
+}
+#endif /* WANT_WIN32_SOCKETS */
+
+void encode64 (char *source,char *destination)
+{
+  static char *Base64Digits =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  int n = 0;
+  int ssiz=strlen(source);
+  int i;
+
+  for (i = 0 ; i < ssiz ; i += 3) {
+    unsigned int buf;
+    buf = ((unsigned char *)source)[i] << 16;
+    if (i+1 < ssiz)
+      buf |= ((unsigned char *)source)[i+1] << 8;
+    if (i+2 < ssiz)
+      buf |= ((unsigned char *)source)[i+2];
+
+    destination[n++] = Base64Digits[(buf >> 18) % 64];
+    destination[n++] = Base64Digits[(buf >> 12) % 64];
+    if (i+1 < ssiz)
+      destination[n++] = Base64Digits[(buf >> 6) % 64];
+    else
+      destination[n++] = '=';
+    if (i+2 < ssiz)
+      destination[n++] = Base64Digits[buf % 64];
+    else
+      destination[n++] = '=';
+  }
+  destination[n++] = 0;
+}
+
+/* Look out for HTTP header field to parse, construct C string with the value.
+   Attention: Modifies argument, since it's so convenient... */
+char *get_header_val(const char *hname, mpg123_string *response)
+{
+	char *tmp = NULL;
+	size_t prelen = strlen(hname);
+	/* if header name found, next char is at least something, so just check for : */
+	if(!strncasecmp(hname, response->p, prelen) && (response->p[prelen] == ':'))
+	{
+		++prelen;
+		if((tmp = strchr(response->p, '\r')) != NULL ) tmp[0] = 0;
+		if((tmp = strchr(response->p, '\n')) != NULL ) tmp[0] = 0;
+		tmp = response->p+prelen;
+		/* I _know_ that there is a terminating zero, so this loop is safe. */
+		while((tmp[0] == ' ') || (tmp[0] == '\t'))
+		{
+			++tmp;
+		}
+	}
+	return tmp;
+}
+
+/* Iterate over header field names and storage locations, to possibly get those values. */
+void get_header_string(mpg123_string *response, const char *fieldname, mpg123_string *store)
+{
+	char *tmp;
+	if((tmp = get_header_val(fieldname, response)))
+	{
+		if(mpg123_set_string(store, tmp)){ debug2("got %s %s", fieldname, store->p); return; }
+		else{ error2("unable to set %s to %s!", fieldname, tmp); }
+	}
+}
+
+/* shoutcsast meta data: 1=on, 0=off */
+
+char *httpauth = NULL;
+
+size_t accept_length(void)
+{
+	int i,j;
+	static size_t l = 0;
+	if(l) return l;
+	l += strlen("Accept: ");
+	for(i=0; mimes[i]    != NULL; ++i)
+	for(j=0; mimes[i][j] != NULL; ++j){ l += strlen(mimes[i][j]) + strlen(", "); }
+	l += strlen("*/*\r\n");
+	debug1("initial computation of accept header length: %lu", (unsigned long)l);
+	return l;
+}
+
+/* Returns TRUE or FALSE for success. */
+int proxy_init(struct httpdata *hd)
+{
+	int ret = TRUE;
+	/* If we don't have explicit proxy given, probe the environment. */
+	if (!param.proxyurl)
+		if (!(param.proxyurl = getenv("MP3_HTTP_PROXY")))
+			if (!(param.proxyurl = getenv("http_proxy")))
+				param.proxyurl = getenv("HTTP_PROXY");
+	/* Now continue if we have something. */
+	if (param.proxyurl && param.proxyurl[0] && strcmp(param.proxyurl, "none"))
+	{
+		mpg123_string proxyurl;
+		mpg123_init_string(&proxyurl);
+		if(   !mpg123_set_string(&proxyurl, param.proxyurl)
+		   || !split_url(&proxyurl, NULL, &hd->proxyhost, &hd->proxyport, NULL))
+		{
+			error("splitting proxy URL");
+			ret = FALSE;
+		}
+		else if(param.verbose > 1) fprintf(stderr, "Note: Using proxy %s\n", hd->proxyhost.p);
+#if 0 /* not yet there */
+		if(!try_host_lookup(proxyhost))
+		{
+			error("Unknown proxy host \"%s\".\n", proxyhost.p);
+			ret = FALSE;
+		}
+#endif
+		mpg123_free_string(&proxyurl);
+		if(ret) hd->proxystate = PROXY_HOST; /* We got hostname and port settled. */
+		else hd->proxystate = PROXY_NONE;
+	}
+	else hd->proxystate = PROXY_NONE;
+
+	return ret;
+}
+
+static int append_accept(mpg123_string *s)
+{
+	size_t i,j;
+	if(!mpg123_add_string(s, "Accept: ")) return FALSE;
+
+	/* We prefer what we know. */
+	for(i=0; mimes[i]    != NULL; ++i)
+	for(j=0; mimes[i][j] != NULL; ++j)
+	{
+		if(   !mpg123_add_string(s, mimes[i][j])
+			 || !mpg123_add_string(s, ", ") )
+		return FALSE;
+	}
+	/* Well... in the end, we accept everything, trying to make sense with reality. */
+	if(!mpg123_add_string(s, "*/*\r\n")) return FALSE;
+
+	return TRUE;
+}
+
+
+/*
+	Converts spaces to "%20" ... actually, I have to ask myself why.
+	What about converting them to "+" instead? Would make things a lot easier.
+	Or, on the other hand... what about avoiding HTML encoding at all?
+*/
+int translate_url(const char *url, mpg123_string *purl)
+{
+	const char *sptr;
+	/* The length of purl is upper bound by 3*strlen(url) + 1 if
+	 * everything in it is a space (%20) - or any encoded character */
+	if (strlen(url) >= SIZE_MAX/3)
+	{
+		error("URL too long. Skipping...");
+		return FALSE;
+	}
+	/* Prepare purl in one chunk, to minimize mallocs. */
+	if(!mpg123_resize_string(purl, strlen(url) + 31)) return FALSE;
+	/*
+	 * 2000-10-21:
+	 * We would like spaces to be automatically converted to %20's when
+	 * fetching via HTTP.
+	 * -- Martin Sj�gren <md9ms@mdstud.chalmers.se>
+	 * Hm, why only spaces? Maybe one should do this http stuff more properly...
+	 */
+	if ((sptr = strchr(url, ' ')) == NULL)
+	mpg123_set_string(purl, url);
+	else
+	{ /* Note that sptr is set from the if to this else... */
+		const char *urlptr = url;
+		mpg123_set_string(purl, "");
+		do {
+			if(! ( mpg123_add_substring(purl, urlptr, 0, sptr-urlptr)
+			       && mpg123_add_string(purl, "%20") ) )
+			return FALSE;
+			urlptr = sptr + 1;
+		} while ((sptr = strchr (urlptr, ' ')) != NULL);
+		if(!mpg123_add_string(purl, urlptr)) return FALSE;
+	}
+	/* now see if a terminating / may be needed */
+	if(strchr(purl->p+(strncmp("http://", purl->p, 7) ? 0 : 7), '/') == NULL
+	    && !mpg123_add_string(purl, "/"))
+	return FALSE;
+
+	return TRUE;
+}
+
+int fill_request(mpg123_string *request, mpg123_string *host, mpg123_string *port, mpg123_string *httpauth1, int *try_without_port)
+{
+	char* ttemp;
+	int ret = TRUE;
+	const char *icy = param.talk_icy ? icy_yes : icy_no;
+
+	/* hm, my test redirection had troubles with line break before HTTP/1.0 */
+	if((ttemp = strchr(request->p,'\r')) != NULL){ *ttemp = 0; request->fill = ttemp-request->p+1; }
+
+	if((ttemp = strchr(request->p,'\n')) != NULL){ *ttemp = 0; request->fill = ttemp-request->p+1; }
+
+	/* Fill out the request further... */
+	if(   !mpg123_add_string(request, " HTTP/1.0\r\nUser-Agent: ")
+		 || !mpg123_add_string(request, PACKAGE_NAME)
+		 || !mpg123_add_string(request, "/")
+		 || !mpg123_add_string(request, PACKAGE_VERSION)
+		 || !mpg123_add_string(request, "\r\n") )
+	return FALSE;
+
+	if(host->fill)
+	{ /* Give virtual hosting a chance... adding the "Host: ... " line. */
+		debug2("Host: %s:%s", host->p, port->p);
+		if(    mpg123_add_string(request, "Host: ")
+			  && mpg123_add_string(request, host->p)
+			  && ( *try_without_port || (
+			         mpg123_add_string(request, ":")
+			      && mpg123_add_string(request, port->p) ))
+			  && mpg123_add_string(request, "\r\n") )
+		{
+			if(*try_without_port) *try_without_port = 0;
+		}
+		else return FALSE;
+	}
+
+	/* Acceptance, stream setup. */
+	if(   !append_accept(request)
+		 || !mpg123_add_string(request, CONN_HEAD)
+		 || !mpg123_add_string(request, icy) )
+	return FALSE;
+
+	/* Authorization. */
+	if (httpauth1->fill || httpauth) {
+		char *buf;
+		if(!mpg123_add_string(request,"Authorization: Basic ")) return FALSE;
+		if(httpauth1->fill) {
+			if(httpauth1->fill > SIZE_MAX / 4) return FALSE;
+
+			buf=(char *)malloc(httpauth1->fill * 4);
+			if(!buf)
+			{
+				error("malloc() failed for http auth, out of memory.");
+				return FALSE;
+			}
+			encode64(httpauth1->p,buf);
+		} else {
+			if(strlen(httpauth) > SIZE_MAX / 4 - 4 ) return FALSE;
+
+			buf=(char *)malloc((strlen(httpauth) + 1) * 4);
+			if(!buf)
+			{
+				error("malloc() for http auth failed, out of memory.");
+				return FALSE;
+			}
+			encode64(httpauth,buf);
+		}
+
+		if( !mpg123_add_string(request, buf) || !mpg123_add_string(request, "\r\n"))
+		ret = FALSE;
+
+		free(buf); /* Watch out for leaking if you introduce returns before this line. */
+	}
+	if(ret) ret = mpg123_add_string(request, "\r\n");
+
+	return ret;
+}
+#if !defined (WANT_WIN32_SOCKETS)
+static int resolve_redirect(mpg123_string *response, mpg123_string *request_url, mpg123_string *purl)
+{
+	debug1("request_url:%s", request_url->p);
+	/* initialized with full old url */
+	if(!mpg123_copy_string(request_url, purl)) return FALSE;
+
+	/* We may strip it down to a prefix ot totally. */
+	if(strncasecmp(response->p, "Location: http://", 17))
+	{ /* OK, only partial strip, need prefix for relative path. */
+		char* ptmp = NULL;
+		/* though it's not RFC (?), accept relative URIs as wget does */
+		fprintf(stderr, "NOTE: no complete URL in redirect, constructing one\n");
+		/* not absolute uri, could still be server-absolute */
+		/* I prepend a part of the request... out of the request */
+		if(response->p[10] == '/')
+		{
+			/* only prepend http://server/ */
+			/* I null the first / after http:// */
+			ptmp = strchr(purl->p+7,'/');
+			if(ptmp != NULL){ purl->fill = ptmp-purl->p+1; purl->p[purl->fill-1] = 0; }
+		}
+		else
+		{
+			/* prepend http://server/path/ */
+			/* now we want the last / */
+			ptmp = strrchr(purl->p+7, '/');
+			if(ptmp != NULL){ purl->fill = ptmp-purl->p+2; purl->p[purl->fill-1] = 0; }
+		}
+	}
+	else purl->fill = 0;
+
+	debug1("prefix=%s", purl->fill ? purl->p : "");
+	if(!mpg123_add_string(purl, response->p+10)) return FALSE;
+
+	debug1("           purl: %s", purl->p);
+	debug1("old request_url: %s", request_url->p);
+
+	return TRUE;
+}
+
+int http_open(char* url, struct httpdata *hd)
+{
+	mpg123_string purl, host, port, path;
+	mpg123_string request, response, request_url;
+	mpg123_string httpauth1;
+	int sock = -1;
+	int oom  = 0;
+	int relocate, numrelocs = 0;
+	int got_location = FALSE;
+	FILE *myfile = NULL;
+	/*
+		workaround for http://www.global24music.com/rautemusik/files/extreme/isdn.pls
+		this site's apache gives me a relocation to the same place when I give the port in Host request field
+		for the record: Apache/2.0.51 (Fedora)
+	*/
+	int try_without_port = 0;
+	mpg123_init_string(&purl);
+	mpg123_init_string(&host);
+	mpg123_init_string(&port);
+	mpg123_init_string(&path);
+	mpg123_init_string(&request);
+	mpg123_init_string(&response);
+	mpg123_init_string(&request_url);
+	mpg123_init_string(&httpauth1);
+
+	/* Get initial info for proxy server. Once. */
+	if(hd->proxystate == PROXY_UNKNOWN && !proxy_init(hd)) goto exit;
+
+	if(!translate_url(url, &purl)){ oom=1; goto exit; }
+
+	/* Don't confuse the different auth strings... */
+	if(!split_url(&purl, &httpauth1, NULL, NULL, NULL) ){ oom=1; goto exit; }
+
+	/* "GET http://"		11
+	 * " HTTP/1.0\r\nUser-Agent: <PACKAGE_NAME>/<PACKAGE_VERSION>\r\n"
+	 * 				26 + PACKAGE_NAME + PACKAGE_VERSION
+	 * accept header            + accept_length()
+	 * "Authorization: Basic \r\n"	23
+	 * "\r\n"			 2
+	 * ... plus the other predefined header lines
+	 */
+	/* Just use this estimate as first guess to reduce malloc calls in string library. */
+	{
+		size_t length_estimate = 62 + strlen(PACKAGE_NAME) + strlen(PACKAGE_VERSION) 
+		                       + accept_length() + strlen(CONN_HEAD) + strlen(icy_yes) + purl.fill;
+		if(    !mpg123_grow_string(&request, length_estimate)
+		    || !mpg123_grow_string(&response,4096) )
+		{
+			oom=1; goto exit;
+		}
+	}
+
+	do
+	{
+		/* Storing the request url, with http:// prepended if needed. */
+		/* used to be url here... seemed wrong to me (when loop advanced...) */
+		if(strncasecmp(purl.p, "http://", 7) != 0) mpg123_set_string(&request_url, "http://");
+		else mpg123_set_string(&request_url, "");
+
+		mpg123_add_string(&request_url, purl.p);
+
+		if (hd->proxystate >= PROXY_HOST)
+		{
+			/* We will connect to proxy, full URL goes into the request. */
+			if(    !mpg123_copy_string(&hd->proxyhost, &host)
+			    || !mpg123_copy_string(&hd->proxyport, &port)
+			    || !mpg123_set_string(&request, "GET ")
+			    || !mpg123_add_string(&request, request_url.p) )
+			{
+				oom=1; goto exit;
+			}
+		}
+		else
+		{
+			/* We will connect to the host from the URL and only the path goes into the request. */
+			if(!split_url(&purl, NULL, &host, &port, &path)){ oom=1; goto exit; }
+			if(    !mpg123_set_string(&request, "GET ")
+			    || !mpg123_add_string(&request, path.p) )
+			{
+				oom=1; goto exit;
+			}
+		}
+
+		if(!fill_request(&request, &host, &port, &httpauth1, &try_without_port)){ oom=1; goto exit; }
+
+		httpauth1.fill = 0; /* We use the auth data from the URL only once. */
+		debug2("attempting to open_connection to %s:%s", host.p, port.p);
+		sock = open_connection(&host, &port);
+		if(sock < 0)
+		{
+			error1("Unable to establish connection to %s", host.fill ? host.p : "");
+			goto exit;
+		}
+#define http_failure close(sock); sock=-1; goto exit;
+		
+		if(param.verbose > 2) fprintf(stderr, "HTTP request:\n%s\n",request.p);
+		if(!writestring(sock, &request)){ http_failure; }
+		if (!(myfile = fdopen(sock, "rb")))
+		{
+			error1("fdopen: %s", strerror(errno));
+			http_failure;
+		}
+		relocate = FALSE;
+		/* Arbitrary length limit here... */
+#define safe_readstring \
+		readstring(&response, SIZE_MAX/16, myfile); \
+		if(response.fill > SIZE_MAX/16) /* > because of appended zero. */ \
+		{ \
+			error("HTTP response line exceeds max. length"); \
+			http_failure; \
+		} \
+		else if(response.fill == 0) \
+		{ \
+			error("readstring failed"); \
+			http_failure; \
+		} \
+		if(param.verbose > 2) fprintf(stderr, "HTTP in: %s", response.p);
+		safe_readstring;
+
+		{
+			char *sptr;
+			if((sptr = strchr(response.p, ' ')))
+			{
+				if(response.fill > sptr-response.p+2)
+				switch (sptr[1])
+				{
+					case '3':
+						relocate = TRUE;
+					case '2':
+						break;
+					default:
+						fprintf (stderr, "HTTP request failed: %s", sptr+1); /* '\n' is included */
+						http_failure;
+				}
+				else{ error("Too short response,"); http_failure; }
+			}
+		}
+
+		/* If we are relocated, we need to look out for a Location header. */
+		got_location = FALSE;
+
+		do
+		{
+			safe_readstring; /* Think about that: Should we really error out when we get nothing? Could be that the server forgot the trailing empty line... */
+			if (!strncasecmp(response.p, "Location: ", 10))
+			{ /* It is a redirection! */
+				if(!resolve_redirect(&response, &request_url, &purl)){ oom=1, http_failure; }
+
+				if(!strcmp(purl.p, request_url.p))
+				{
+					warning("relocated to very same place! trying request again without host port");
+					try_without_port = 1;
+				}
+				got_location = TRUE;
+			}
+			else
+			{ /* We got a header line (or the closing empty line). */
+				char *tmp;
+				debug1("searching for header values... %s", response.p);
+				/* Not sure if I want to bail out on error here. */
+				/* Also: What text encoding are these strings in? Doesn't need to be plain ASCII... */
+				get_header_string(&response, "content-type", &hd->content_type);
+				get_header_string(&response, "icy-name",     &hd->icy_name);
+				get_header_string(&response, "icy-url",      &hd->icy_url);
+
+				/* watch out for icy-metaint */
+				if((tmp = get_header_val("icy-metaint", &response)))
+				{
+					hd->icy_interval = (off_t) atol(tmp); /* atoll ? */
+					debug1("got icy-metaint %li", (long int)hd->icy_interval);
+				}
+			}
+		} while(response.p[0] != '\r' && response.p[0] != '\n');
+	} while(relocate && got_location && purl.fill && numrelocs++ < HTTP_MAX_RELOCATIONS);
+	if(relocate)
+	{
+		if(!got_location)
+		error("Server meant to redirect but failed to provide a location!");
+		else
+		error1("Too many HTTP relocations (%i).", numrelocs);
+
+		http_failure;
+	}
+
+exit: /* The end as well as the exception handling point... */
+	if(oom) error("Apparently, I ran out of memory or had some bad input data...");
+
+	mpg123_free_string(&purl);
+	mpg123_free_string(&host);
+	mpg123_free_string(&port);
+	mpg123_free_string(&path);
+	mpg123_free_string(&request);
+	mpg123_free_string(&response);
+	mpg123_free_string(&request_url);
+	mpg123_free_string(&httpauth1);
+	return sock;
+}
+#endif /*WANT_WIN32_SOCKETS*/
+
+#else /* NETWORK */
+
+/* stub */
+int http_open (char* url, struct httpdata *hd)
+{
+	return -1;
+}
+#endif
+
+/* EOF */
+