seal 0.1.0

data/mpg123/src/wavhead.h

@@ -0,0 +1,68 @@
+/*
+	wavhead.h: wav file header, to be included twice for integer and float wavs
+
+	copyright ?-2008 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 by Samuel Audet
+*/
+
+struct
+{
+	byte riffheader[4];
+	byte WAVElen[4]; /* should this include riffheader or not? */
+	struct
+	{
+		byte WAVEID[4];
+		byte fmtheader[4];
+		byte fmtlen[4];
+		struct
+		{
+			byte FormatTag[2];
+			byte Channels[2];
+			byte SamplesPerSec[4];
+			byte AvgBytesPerSec[4];
+			byte BlockAlign[2];
+			byte BitsPerSample[2]; /* format specific for PCM */
+			#ifdef FLOATOUT
+			byte cbSize[2];
+			#endif
+		} fmt;
+		#ifdef FLOATOUT
+		byte factheader[4];
+		byte factlen[4];
+		struct
+		{
+			byte samplelen[4];
+		} fact;
+		#endif
+		struct
+		{
+			byte dataheader[4];
+			byte datalen[4];
+			/* from here you insert your PCM data */
+		} data;
+	} WAVE;
+} RIFF_NAME = 
+{
+	{ 'R','I','F','F' } ,
+	{ sizeof(RIFF_NAME.WAVE),0,0,0 } , 
+	{
+		{ 'W','A','V','E' },
+		{ 'f','m','t',' ' },
+		{ sizeof(RIFF_NAME.WAVE.fmt),0,0,0 } ,
+		{
+			{WAVE_FORMAT,0} , {0,0},{0,0,0,0},{0,0,0,0},{0,0},{0,0}
+			#ifdef FLOATOUT
+			,{0,0}
+			#endif
+		} ,
+		#ifdef FLOATOUT
+		{ 'f','a','c','t' },
+		{ sizeof(RIFF_NAME.WAVE.fact),0,0,0 },
+		{
+			{0,0,0,0} /* to be filled later, like datalen and wavelen */
+		},
+		#endif
+		{ { 'd','a','t','a' }  , {0,0,0,0} }
+	}
+};

data/mpg123/src/win32_net.c

@@ -0,0 +1,599 @@
+#include "config.h"
+#include "mpg123.h"
+#include "mpg123app.h"
+#include "httpget.h"
+#include "debug.h"
+#include "resolver.h"
+#include "compat.h"
+#include <errno.h>
+
+#if defined (WANT_WIN32_SOCKETS)
+#ifdef DEBUG
+#define msgme(x) win32_net_msg(x,__FILE__,__LINE__)
+#define msgme1 win32_net_msg(1,__FILE__,__LINE__)
+#define msgme_sock_err(x) if ((x)==SOCKET_ERROR) {msgme1;}
+#else
+#define msgme(x) x
+#define msgme1 do{} while(0)
+#define msgme_sock_err(x) x
+#endif
+struct ws_local
+{
+  int inited;
+  SOCKET local_socket; /*stores last connet in win32_net_open_connection*/
+  WSADATA wsadata;
+};
+
+static struct ws_local ws;
+#ifdef DEBUG
+static void win32_net_msg (const int err, const char * const filedata, const int linedata)
+{
+  char *errbuff;
+  int lc_err;
+  if (err)
+  {
+    lc_err = WSAGetLastError();
+    FormatMessage(
+      FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
+      NULL,
+      lc_err,
+      MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+      (LPTSTR) &errbuff,
+      0,
+      NULL );
+    fprintf(stderr, "[%s:%d] [WSA2: %d] %s", filedata, linedata, lc_err, errbuff);
+    LocalFree (errbuff);
+  }
+}
+#endif
+
+void win32_net_init (void)
+{
+  ws.inited = 1;
+  switch ((WSAStartup(MAKEWORD(2,2), &ws.wsadata)))
+  {
+    case WSASYSNOTREADY: debug("WSAStartup failed with WSASYSNOTREADY"); break;
+    case WSAVERNOTSUPPORTED: debug("WSAStartup failed with WSAVERNOTSUPPORTED"); break;
+    case WSAEINPROGRESS: debug("WSAStartup failed with WSAEINPROGRESS"); break;
+    case WSAEPROCLIM: debug("WSAStartup failed with WSAEPROCLIM"); break;
+    case WSAEFAULT: debug("WSAStartup failed with WSAEFAULT"); break;
+    default:
+    break;
+  }
+}
+
+void win32_net_deinit (void)
+{
+  debug("Begin winsock cleanup");
+  if (ws.inited)
+  {
+    if (ws.inited >= 2 && ws.local_socket != SOCKET_ERROR)
+    {
+      debug1("ws.local_socket = %"SIZE_P"", (size_p)ws.local_socket);
+      msgme_sock_err(shutdown(ws.local_socket, SD_BOTH));
+      win32_net_close(ws.local_socket);
+    }
+    WSACleanup();
+    ws.inited = 0;
+  }
+}
+
+void win32_net_close (int sock)
+{
+    msgme_sock_err(closesocket(ws.local_socket));
+}
+
+static void win32_net_nonblock(int sock)
+{
+  u_long mode = 1;
+  msgme_sock_err(ioctlsocket(ws.local_socket, FIONBIO, &mode));
+}
+
+static void win32_net_block(int sock)
+{
+  u_long mode = 0;
+  msgme_sock_err(ioctlsocket(ws.local_socket, FIONBIO, &mode));
+}
+
+ssize_t win32_net_read (int fildes, void *buf, size_t nbyte)
+{
+  debug1("Attempting to read %"SIZE_P" bytes from network.", (size_p)nbyte);
+  ssize_t ret;
+  msgme_sock_err(ret = (ssize_t) recv(ws.local_socket, buf, nbyte, 0));
+  debug1("Read %"SSIZE_P" bytes from network.", (ssize_p)ret);
+
+  return ret;
+}
+
+static int get_sock_ch (int sock)
+{
+  char c;
+  int ret;
+  msgme_sock_err(ret = recv (ws.local_socket, &c, 1, 0));
+  if (ret == 1)
+    return (((int) c)&0xff);
+  return -1;
+}
+/* Addapted from from newlib*/
+char *win32_net_fgets(char *s, int n, int stream)
+{
+  char c = 0;
+  char *buf;
+  buf = s;
+  debug1("Pseudo net fgets attempts to read %d bytes from network.", n - 1);
+  while (--n > 0 && (c = get_sock_ch (stream)) != -1)
+  {
+    *s++ = c;
+    if (c == '\n' || c == '\r')
+      break;
+  }
+  debug1("Pseudo net fgets got %"SIZE_P" bytes.", (size_p)(s - buf));
+  if (c == -1 && s == buf)
+  {
+    debug("Pseudo net fgets met a premature end.");
+    return NULL;
+  }
+  *s = 0;
+  return buf;
+}
+
+ssize_t win32_net_write (int fildes, const void *buf, size_t nbyte)
+{
+  debug1("Attempting to write %"SIZE_P" bytes to network.", (size_p)nbyte);
+  ssize_t ret;
+  msgme_sock_err((ret = (ssize_t) send(ws.local_socket, buf, nbyte, 0)));
+  debug1("wrote %"SSIZE_P" bytes to network.", (ssize_t)ret);
+
+  return ret;
+}
+
+off_t win32_net_lseek (int a, off_t b, int c)
+{
+  debug("lseek on a socket called!");
+  return -1;
+}
+
+void win32_net_replace (mpg123_handle *fr)
+{
+  debug("win32_net_replace ran");
+  mpg123_replace_reader(fr, win32_net_read, win32_net_lseek);
+}
+
+static int win32_net_timeout_connect(int sockfd, const struct sockaddr *serv_addr, socklen_t addrlen)
+{
+	debug("win32_net_timeout_connect ran");
+	if(param.timeout > 0)
+	{
+		int err;
+		win32_net_nonblock(ws.local_socket);
+		err = connect(ws.local_socket, serv_addr, addrlen);
+		if(err != SOCKET_ERROR)
+		{
+			debug("immediately successful");
+			win32_net_block(ws.local_socket);
+			return 0;
+		}
+		else if(WSAGetLastError() == WSAEWOULDBLOCK) /*WSAEINPROGRESS would not work here for some reason*/
+		{
+			struct timeval tv;
+			fd_set fds;
+			tv.tv_sec = param.timeout;
+			tv.tv_usec = 0;
+
+			debug("in progress, waiting...");
+
+			FD_ZERO(&fds);
+			FD_SET(ws.local_socket, &fds);
+			err = select(ws.local_socket+1, NULL, &fds, NULL, &tv);
+			if(err != SOCKET_ERROR)
+			{
+				socklen_t len = sizeof(err);
+				if((getsockopt(ws.local_socket, SOL_SOCKET, SO_ERROR, (char *)&err, &len) != SOCKET_ERROR)
+				   && (err == 0) )
+				{
+					debug("non-blocking connect has been successful");
+					win32_net_block(ws.local_socket);
+					return 0;
+				}
+				else
+				{
+					//error1("connection error: %s", msgme(err));
+					return -1;
+				}
+			}
+			else if(err == 0)
+			{
+				error("connection timed out");
+				return -1;
+			}
+			else
+			{
+				/*error1("error from select(): %s", strerror(errno));*/
+				debug("error from select():");
+				msgme1;
+				return -1;
+			}
+		}
+		else
+		{
+			/*error1("connection failed: %s", strerror(errno));*/
+			debug("connection failed: ");
+			msgme1;
+			return err;
+		}
+	}
+	else
+	{
+		if(connect(ws.local_socket, serv_addr, addrlen) == SOCKET_ERROR)
+		{
+			/*error1("connecton failed: %s", strerror(errno));*/
+			debug("connecton failed");
+			msgme1;
+			return -1;
+		}
+		else {
+		debug("win32_net_timeout_connect succeed");
+		return 0; /* _good_ */
+		}
+	}
+}
+
+static int win32_net_open_connection(mpg123_string *host, mpg123_string *port)
+{
+	struct addrinfo hints;
+	struct addrinfo *addr, *addrlist;
+	SOCKET addrcount;
+	ws.local_socket = SOCKET_ERROR;
+
+	if(param.verbose>1) fprintf(stderr, "Note: Attempting new-style connection to %s\n", host->p);
+	memset(&hints, 0, sizeof(struct addrinfo));
+	hints.ai_family   = AF_UNSPEC; /* We accept both IPv4 and IPv6 ... and perhaps IPv8;-) */
+	hints.ai_socktype = SOCK_STREAM;
+	hints.ai_protocol = IPPROTO_TCP;
+
+	debug2("Atempt resolve/connect to %s:%s", host->p, port->p);
+	msgme(addrcount = getaddrinfo(host->p, port->p, &hints, &addrlist));
+
+	if(addrcount == INVALID_SOCKET)
+	{
+		error3("Resolving %s:%s: %s", host->p, port->p, gai_strerror(addrcount));
+		return -1;
+	}
+
+	addr = addrlist;
+	while(addr != NULL)
+	{
+		ws.local_socket = socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);
+		if (ws.local_socket == INVALID_SOCKET)
+		{
+			msgme1;
+		}
+		else
+		{
+			if(win32_net_timeout_connect(ws.local_socket, addr->ai_addr, addr->ai_addrlen) == 0)
+			break;
+			debug("win32_net_timeout_connect error, closing socket");
+			win32_net_close(ws.local_socket);
+			ws.local_socket=SOCKET_ERROR;
+		}
+		addr=addr->ai_next;
+	}
+	if(ws.local_socket == SOCKET_ERROR) {error2("Cannot resolve/connect to %s:%s!", host->p, port->p);}
+	else
+	{
+	  ws.inited = 2;
+	}
+
+	freeaddrinfo(addrlist);
+	return 1;
+}
+
+static size_t win32_net_readstring (mpg123_string *string, size_t maxlen, FILE *f)
+{
+	debug2("Attempting readstring on %d for %"SIZE_P" bytes", f ? fileno(f) : -1, (size_p)maxlen);
+	int err;
+	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 = win32_net_read(0,string->p+string->fill,1); /*fd is ignored */
+		/* 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;
+}
+
+static int win32_net_writestring (int fd, mpg123_string *string)
+{
+	size_t result, bytes;
+	char *ptr = string->p;
+	bytes = string->fill ? string->fill-1 : 0;
+
+	while(bytes)
+	{
+		result = win32_net_write(ws.local_socket, ptr, bytes);
+		if(result < 0 && WSAGetLastError() != WSAEINTR)
+		{
+			perror ("writing http string");
+			return FALSE;
+		}
+		else if(result == 0)
+		{
+			error("write: socket closed unexpectedly");
+			return FALSE;
+		}
+		ptr   += result;
+		bytes -= result;
+	}
+	return TRUE;
+}
+
+static int win32_net_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 win32_net_http_open(char* url, struct httpdata *hd)
+{
+	mpg123_string purl, host, port, path;
+	mpg123_string request, response, request_url;
+	mpg123_string httpauth1;
+	ws.local_socket = SOCKET_ERROR;
+	int oom  = 0;
+	int relocate, numrelocs = 0;
+	int got_location = FALSE;
+	/*
+		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);
+		win32_net_open_connection(&host, &port);
+		if(ws.local_socket == SOCKET_ERROR)
+		{
+			error1("Unable to establish connection to %s", host.fill ? host.p : "");
+			goto exit;
+		}
+		debug("win32_net_open_connection succeed");
+#define http_failure win32_net_close(ws.local_socket); ws.local_socket=SOCKET_ERROR; goto exit;
+		
+		if(param.verbose > 2) fprintf(stderr, "HTTP request:\n%s\n",request.p);
+		if(!win32_net_writestring(ws.local_socket, &request)){ http_failure; }
+		debug("Skipping fdopen for WSA sockets");
+		relocate = FALSE;
+		/* Arbitrary length limit here... */
+#define safe_readstring \
+		win32_net_readstring(&response, SIZE_MAX/16, NULL); \
+		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(!win32_net_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);
+	if (ws.local_socket == SOCKET_ERROR || oom)
+	return -1;
+	else
+	return 1;
+}
+#else
+int win32_net_http_open(char* url, struct httpdata *hd)
+{
+  return -1;
+}
+#endif /*WANT_WIN32_SOCKETS */