seal 0.1.0

data/mpg123/src/win32_support.c

@@ -0,0 +1,191 @@
+#include "config.h"
+#include "mpg123app.h"
+#include "debug.h"
+
+#ifdef WANT_WIN32_UNICODE
+
+/* Obscure and undocumented call from MS C Runtime "MSVCRT.DLL" */
+typedef struct
+{
+	int newmode;
+} _startupinfo;
+
+int __cdecl __declspec(dllimport) __wgetmainargs (
+	int *_Argc,
+	wchar_t ***_Argv,
+	wchar_t ***_Env,
+	int _DoWildCard,
+	_startupinfo * _StartInfo
+);
+
+int win32_cmdline_utf8(int * argc, char *** argv)
+{
+	int argcounter, ret;
+	wchar_t **argv_wide;
+	wchar_t **env;
+	char *argvptr;
+	_startupinfo startup;
+
+	/* That's too lame. */
+	if(argv == NULL || argc == NULL) return -1;
+
+	startup.newmode = 0;
+	ret = __wgetmainargs(argc, &argv_wide,&env,1, &startup);
+	*argv = (char **)calloc(sizeof (char *), *argc);
+	if(*argv == NULL){ error("Cannot allocate memory for command line."); return -1; }
+
+	for(argcounter = 0; argcounter < *argc; argcounter++)
+	{
+		win32_wide_utf8(argv_wide[argcounter], &argvptr, NULL);
+		(*argv)[argcounter] = argvptr;
+	}
+	return ret;
+}
+
+void win32_cmdline_free(int argc, char **argv)
+{
+	int i;
+	if(argv == NULL) return;
+	for(i=0; i<argc; ++i) free(argv[i]);
+}
+#endif /* WANT_WIN32_UNICODE */
+
+void win32_set_priority (const int arg)
+{
+	DWORD proc_result = 0;
+	HANDLE current_proc = NULL;
+	if(arg)
+	{
+		if((current_proc = GetCurrentProcess()))
+		{
+			switch(arg)
+			{
+				case -2: proc_result = SetPriorityClass(current_proc, IDLE_PRIORITY_CLASS); break;  
+				case -1: proc_result = SetPriorityClass(current_proc, BELOW_NORMAL_PRIORITY_CLASS); break;  
+				case 0: proc_result = SetPriorityClass(current_proc, NORMAL_PRIORITY_CLASS); break; /*default priority*/
+				case 1: proc_result = SetPriorityClass(current_proc, ABOVE_NORMAL_PRIORITY_CLASS); break;
+				case 2: proc_result = SetPriorityClass(current_proc, HIGH_PRIORITY_CLASS); break;
+				case 3: proc_result = SetPriorityClass(current_proc, REALTIME_PRIORITY_CLASS); break;
+				default: fprintf(stderr,"Unknown priority class specified\n");
+			}
+			if(!proc_result) fprintf(stderr,"SetPriorityClass failed\n");
+		}
+		else fprintf(stderr,"GetCurrentProcess failed\n");
+	}
+}
+
+#ifdef WANT_WIN32_FIFO
+static HANDLE fifohandle;
+static OVERLAPPED ov1;
+
+VOID CALLBACK ReadComplete(
+	DWORD dwErrorCode,
+	DWORD dwNumberOfBytesTransfered,
+	LPOVERLAPPED lpOverlapped
+)
+{
+	/* Reset OVERLAPPED structure */
+	debug("ReadFileEx completed");
+	memset(lpOverlapped,0,sizeof(OVERLAPPED));
+	return;
+}
+
+ssize_t win32_fifo_read(void *buf, size_t nbyte)
+{
+	int check;
+	DWORD re;
+	DWORD readbuff;
+	DWORD available;
+	debug1("Reading pipe handle %p", fifohandle);
+	if (!fifohandle) return 0;
+
+	available = win32_fifo_read_peek(NULL);
+	if (!available) return 0;
+
+	/* This looks more like a hack than a proper check */
+	readbuff = (nbyte > available) ? available : nbyte;
+	debug("Starting ReadFileEx");
+	check = ReadFileEx(fifohandle,buf,readbuff,&ov1,&ReadComplete);
+	WaitForSingleObjectEx(fifohandle,INFINITE,TRUE);
+	debug1("Read %ld bytes from pipe", readbuff);
+	return (!check) ? 0 : readbuff;
+}
+
+/* function should be able to tell if bytes are
+   available and return immediately on overlapped
+   asynchrounous pipes, like unix select() */
+DWORD win32_fifo_read_peek(struct timeval *tv)
+{
+	DWORD ret = 0;
+	DWORD err, timer;
+
+	timer = (tv) ? tv -> tv_sec * 1000 : INFINITE;
+
+	debug1("Peeking on pipe handle %p", fifohandle);
+
+	SetLastError(0);
+	if(!fifohandle) return 0;
+		PeekNamedPipe(fifohandle, NULL, 0, NULL, &ret, NULL);
+	err =  GetLastError();
+	debug1("Waiting %d msec for pipe to be ready", timer);
+	debug1("GetLastError was %ld", err);
+	if(err == ERROR_BROKEN_PIPE)
+	{
+		debug("Broken pipe, disconnecting");
+		DisconnectNamedPipe(fifohandle);
+		ConnectNamedPipe(fifohandle,&ov1);
+		WaitForSingleObjectEx(fifohandle,timer,TRUE);
+	}
+	else if(err == ERROR_BAD_PIPE)
+	{
+		debug("Bad pipe, Waiting for connect");
+		DisconnectNamedPipe(fifohandle);
+		ConnectNamedPipe(fifohandle,&ov1);
+		WaitForSingleObjectEx(fifohandle,timer,TRUE);
+	}
+	debug2("peek %d bytes, error %d",ret, err);
+	return ret;
+}
+
+void win32_fifo_close(void)
+{
+	debug1("Attempting to close handle %p", fifohandle);
+	if(fifohandle)
+	{
+		DisconnectNamedPipe(fifohandle);
+		CloseHandle(fifohandle);
+	}
+	fifohandle = NULL;
+}
+
+int win32_fifo_mkfifo(const char *path)
+{
+	HANDLE ret;
+	win32_fifo_close();
+#ifdef WANT_WIN32_UNICODE
+	wchar_t *str;
+	if(win32_utf8_wide(path,&str,NULL) == 0)
+	{
+		fprintf(stderr,"Cannot get FIFO name, likely out of memory\n");
+		return -1;
+	}
+#if (DEBUG == 1)
+	fwprintf(stderr,L"CreateNamedPipeW %ws\n", str);
+#endif
+	ret = CreateNamedPipeW(str,PIPE_ACCESS_DUPLEX|FILE_FLAG_OVERLAPPED,PIPE_TYPE_BYTE,1,255,255,0,NULL);
+	free(str);
+#else
+#if (DEBUG == 1)
+	fprintf(stderr,"CreateNamedPipeA %s\n", path);
+#endif
+	ret = CreateNamedPipeA(path,PIPE_ACCESS_DUPLEX|FILE_FLAG_OVERLAPPED,PIPE_TYPE_BYTE,1,255,255,0,NULL);
+#endif /* WANT_WIN32_UNICODE */
+	if(ret == INVALID_HANDLE_VALUE) return -1;
+
+	fifohandle = ret;
+	/* Wait for client */
+	ConnectNamedPipe(fifohandle,&ov1);
+	WaitForSingleObjectEx(fifohandle,INFINITE,TRUE);
+	return 0;
+}
+#endif /* WANT_WIN32_FIFO */

data/mpg123/src/win32_support.h

@@ -0,0 +1,152 @@
+/*
+	Win32 support helper file
+
+	This file is only for use with the mpg123 frontend.
+	win32 support helpers for libmpg123 are in src/libmpg123/compat.h
+*/
+#ifndef MPG123_WIN32_SUPPORT_H
+#define MPG123_WIN32_SUPPORT_H
+
+#include "config.h"
+#include "mpg123.h"
+#ifdef HAVE_WINDOWS_H
+
+#define WIN32_LEAN_AND_MEAN 1
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <wchar.h>
+#include <windows.h>
+#include <winnls.h>
+#include <shellapi.h>
+#include <mmsystem.h>
+
+#if defined (HAVE_WS2TCPIP_H) && !defined (__CYGWIN__)
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#endif
+
+#if defined (WANT_WIN32_SOCKETS) /*conflict with gethostname and select in select.h and unistd.h */
+/* 
+Note: Do not treat return values as valid file/socket handles, they only indicate success/failure.
+file descriptors are ignored, only the local ws.local_socket is used for storing socket handle,
+so the socket handle is always associated with the last call to win32_net_http_open
+*/
+
+/**
+ * Opens an http URL
+ * @param[in] url URL to open
+ * @param[out] hd http data info
+ * @return -1 for failure, 1 for success
+ */
+int win32_net_http_open(char* url, struct httpdata *hd);
+
+/**
+ * Reads from network socket
+ * @param[in] filedes Value is ignored, last open connection is used.
+ * @param[out] buf buffer to store data.
+ * @param[in] nbyte bytes to read.
+ * @return bytes read successfully from socket
+ */
+ssize_t win32_net_read (int fildes, void *buf, size_t nbyte);
+
+/**
+ * Writes to network socket
+ * @param[in] filedes Value is ignored, last open connection is used.
+ * @param[in] buf buffer to read data from.
+ * @param[in] nbyte bytes to write.
+ * @return bytes written successfully to socket
+ */
+ssize_t win32_net_write (int fildes, const void *buf, size_t nbyte);
+
+/**
+ * Similar to fgets - get a string from a stream
+ * @param[out] s buffer to Write to
+ * @param[in] n bytes of data to read.
+ * @param[in] stream ignored for compatiblity, last open connection is used.
+ * @return pointer to s if successful, NULL if failture
+ */
+char *win32_net_fgets(char *s, int n, int stream);
+
+/**
+ * Initialize Winsock 2.2.
+ */
+void win32_net_init (void);
+
+/**
+ * Shutdown all win32 sockets.
+ */
+void win32_net_deinit (void);
+
+/**
+ * Close last open socket.
+ * @param[in] sock value is ignored.
+ */
+void win32_net_close (int sock);
+
+/**
+ * Set reader callback for mpg123_open_fd
+ * @param[in] fr pointer to a mpg123_handle struct.
+ */
+void win32_net_replace (mpg123_handle *fr);
+#endif
+
+#ifdef WANT_WIN32_UNICODE
+/**
+ * Put the windows command line into argv / argc, encoded in UTF-8.
+ * You are supposed to free up resources by calling win32_cmdline_free with the values you got from this one.
+ * @return 0 on success, -1 on error */
+int win32_cmdline_utf8(int * argc, char *** argv);
+
+/**
+ * Free up cmdline memory (the argv itself, theoretically hidden resources, too).
+ */
+void win32_cmdline_free(int argc, char **argv);
+
+#endif /* WIN32_WANT_UNICODE */
+
+/**
+ * Set process priority
+ * @param arg -2: Idle, -1, bellow normal, 0, normal (ignored), 1 above normal, 2 highest, 3 realtime
+ */
+void win32_set_priority (const int arg);
+
+#ifdef WANT_WIN32_FIFO
+/**
+ * win32_fifo_mkfifo
+ * Creates a named pipe of path.
+ * Should be closed with win32_fifo_close.
+ * @param[in] path Path of pipe, should be in form of "\\.\pipe\pipename".
+ * @return -1 on failure, 0 otherwise.
+ * @see win32_fifo_close
+ */
+int win32_fifo_mkfifo(const char *path);
+
+/**
+ *win32_fifo_close
+ * Closes previously open pipe
+ */
+void win32_fifo_close(void);
+
+/**
+ * win32_fifo_read_peek
+ * Checks how many bytes in fifo is pending read operation
+ * Only the tv_sec member in timeval is evaluated! No microsecond precision.
+ * @param[in] tv contains information on block duration
+ * @return bytes available
+ */
+DWORD win32_fifo_read_peek(struct timeval *tv);
+
+/***
+ * win32_fifo_read
+ * Read up to nbyte of data from open pipe into buf
+ * @param[in] buf Pointer to buffer.
+ * @param[in] nbyte Number of bytes to read up to.
+ * @return Number of bytes actually read.
+ */
+ssize_t win32_fifo_read(void *buf, size_t nbyte);
+#endif /* #ifdef WANT_WIN32_FIFO */
+
+#endif /* HAVE_WINDOWS_H */
+#endif /* MPG123_WIN32_SUPPORT_H */
+

data/mpg123/src/xfermem.c

@@ -0,0 +1,321 @@
+/*
+	xfermem: unidirectional fast pipe
+
+	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 Oliver Fromme
+	old timestamp: Sun Apr  6 02:26:26 MET DST 1997
+
+	See xfermem.h for documentation/description.
+*/
+
+
+#ifndef NOXFERMEM
+
+#include "mpg123app.h"
+#include <string.h>
+#include <errno.h>
+#include <sys/uio.h>
+#include <sys/mman.h>
+#include <sys/socket.h>
+#include <fcntl.h>
+
+#ifndef HAVE_MMAP
+#include <sys/ipc.h>
+#include <sys/shm.h>
+#endif
+
+#include "debug.h"
+
+#if defined (HAVE_MMAP) && defined(MAP_ANONYMOUS) && !defined(MAP_ANON)
+#define MAP_ANON MAP_ANONYMOUS
+#endif
+
+void xfermem_init (txfermem **xf, size_t bufsize, size_t msize, size_t skipbuf)
+{
+	size_t regsize = bufsize + msize + skipbuf + sizeof(txfermem);
+
+#ifdef HAVE_MMAP
+#  ifdef MAP_ANON
+	if ((*xf = (txfermem *) mmap(0, regsize, PROT_READ | PROT_WRITE,
+			MAP_ANON | MAP_SHARED, -1, 0)) == (txfermem *) -1) {
+		perror ("mmap()");
+		exit (1);
+	}
+#  else
+	int devzero;
+	if ((devzero = open("/dev/zero", O_RDWR, 0)) == -1) {
+		perror ("open(/dev/zero)");
+		exit (1);
+	}
+	if ((*xf = (txfermem *) mmap(0, regsize, PROT_READ | PROT_WRITE,
+			MAP_SHARED, devzero, 0)) == (txfermem *) -1) {
+		perror ("mmap()");
+		exit (1);
+	}
+	close (devzero);
+#  endif
+#else
+	struct shmid_ds shmemds;
+	int shmemid;
+	if ((shmemid = shmget(IPC_PRIVATE, regsize, IPC_CREAT | 0600)) == -1) {
+		perror ("shmget()");
+		exit (1);
+	}
+	if ((*xf = (txfermem *) shmat(shmemid, 0, 0)) == (txfermem *) -1) {
+		perror ("shmat()");
+		shmctl (shmemid, IPC_RMID, &shmemds);
+		exit (1);
+	}
+	if (shmctl(shmemid, IPC_RMID, &shmemds) == -1) {
+		perror ("shmctl()");
+		xfermem_done (*xf);
+		exit (1);
+	}
+#endif
+	if (socketpair(AF_UNIX, SOCK_STREAM, 0, (*xf)->fd) < 0) {
+		perror ("socketpair()");
+		xfermem_done (*xf);
+		exit (1);
+	}
+	(*xf)->freeindex = (*xf)->readindex = 0;
+	(*xf)->wakeme[0] = (*xf)->wakeme[1] = FALSE;
+	(*xf)->data = ((byte *) *xf) + sizeof(txfermem) + msize;
+	(*xf)->metadata = ((byte *) *xf) + sizeof(txfermem);
+	(*xf)->size = bufsize;
+	(*xf)->metasize = msize + skipbuf;
+	(*xf)->justwait = 0;
+}
+
+void xfermem_done (txfermem *xf)
+{
+	if(!xf)
+		return;
+#ifdef HAVE_MMAP
+	munmap ((caddr_t) xf, xf->size + xf->metasize + sizeof(txfermem));
+#else
+	if (shmdt((void *) xf) == -1) {
+		perror ("shmdt()");
+		exit (1);
+	}
+#endif
+}
+
+void xfermem_init_writer (txfermem *xf)
+{
+	if(xf)
+		close (xf->fd[XF_READER]);
+}
+
+void xfermem_init_reader (txfermem *xf)
+{
+	if(xf)
+		close (xf->fd[XF_WRITER]);
+}
+
+size_t xfermem_get_freespace (txfermem *xf)
+{
+	size_t freeindex, readindex;
+
+	if(!xf)
+		return 0;
+
+	if ((freeindex = xf->freeindex) < 0
+			|| (readindex = xf->readindex) < 0)
+		return (0);
+	if (readindex > freeindex)
+		return ((readindex - freeindex) - 1);
+	else
+		return ((xf->size - (freeindex - readindex)) - 1);
+}
+
+size_t xfermem_get_usedspace (txfermem *xf)
+{
+	size_t freeindex, readindex;
+
+	if(!xf)
+		return 0;
+
+	if ((freeindex = xf->freeindex) < 0
+			|| (readindex = xf->readindex) < 0)
+		return (0);
+	if (freeindex >= readindex)
+		return (freeindex - readindex);
+	else
+		return (xf->size - (readindex - freeindex));
+}
+
+int xfermem_getcmd (int fd, int block)
+{
+	fd_set selfds;
+	byte cmd;
+
+	for (;;) {
+		struct timeval selto = {0, 0};
+
+		FD_ZERO (&selfds);
+		FD_SET (fd, &selfds);
+#ifdef HPUX
+		switch (select(FD_SETSIZE, (int *) &selfds, NULL, NULL, block ? NULL : &selto)) {
+#else
+		switch (select(FD_SETSIZE, &selfds, NULL, NULL, block ? NULL : &selto)) {
+#endif
+			case 0:
+				if (!block)
+					return (0);
+				continue;
+			case -1:
+				if (errno == EINTR)
+					continue;
+				return (-2);
+			case 1:
+				if (FD_ISSET(fd, &selfds))
+					switch (read(fd, &cmd, 1)) {
+						case 0: /* EOF */
+							return (-1);
+						case -1:
+							if (errno == EINTR)
+								continue;
+							return (-3);
+						case 1:
+							return (cmd);
+						default: /* ?!? */
+							return (-4);
+					}
+				else /* ?!? */
+					return (-5);
+			default: /* ?!? */
+				return (-6);
+		}
+	}
+}
+
+int xfermem_putcmd (int fd, byte cmd)
+{
+	for (;;) {
+		switch (write(fd, &cmd, 1)) {
+			case 1:
+				return (1);
+			case -1:
+				if (errno != EINTR)
+					return (-1);
+		}
+	}
+}
+
+int xfermem_block (int readwrite, txfermem *xf)
+{
+	int myfd = xf->fd[readwrite];
+	int result;
+
+	xf->wakeme[readwrite] = TRUE;
+	if (xf->wakeme[1 - readwrite])
+		xfermem_putcmd (myfd, XF_CMD_WAKEUP);
+	result = xfermem_getcmd(myfd, TRUE);
+	xf->wakeme[readwrite] = FALSE;
+	return ((result <= 0) ? -1 : result);
+}
+
+/* Parallel-safe code to signal a process and wait for it to respond. */
+int xfermem_sigblock(int readwrite, txfermem *xf, int pid, int signal)
+{
+	int myfd = xf->fd[readwrite];
+	int result;
+
+	xf->wakeme[readwrite] = TRUE;
+	kill(pid, signal);
+
+	/* not sure about that block... here */
+	if (xf->wakeme[1 - readwrite])
+		xfermem_putcmd (myfd, XF_CMD_WAKEUP);
+
+	result = xfermem_getcmd(myfd, TRUE);
+	xf->wakeme[readwrite] = FALSE;
+
+	return ((result <= 0) ? -1 : result);
+}
+
+int xfermem_write(txfermem *xf, byte *buffer, size_t bytes)
+{
+	if(buffer == NULL || bytes < 1) return FALSE;
+
+	/* You weren't so braindead to have not allocated enough space at all, right? */
+	while (xfermem_get_freespace(xf) < bytes)
+	{
+		int cmd =  xfermem_block(XF_WRITER, xf);
+		if (cmd == XF_CMD_TERMINATE || cmd < 0)
+		{
+			error("failed to wait for free space");
+			return TRUE; /* Failure. */
+		}
+	}
+	/* Now we have enough space. copy the memory, possibly with the wrap. */
+	if(xf->size - xf->freeindex >= bytes)
+	{	/* one block of free memory */
+		memcpy(xf->data+xf->freeindex, buffer, bytes);
+	}
+	else
+	{ /* two blocks */
+		size_t endblock = xf->size - xf->freeindex;
+		memcpy(xf->data+xf->freeindex, buffer, endblock);
+		memcpy(xf->data, buffer + endblock, bytes-endblock);
+	}
+	/* Advance the free space pointer, including the wrap. */
+	xf->freeindex = (xf->freeindex + bytes) % xf->size;
+	/* Wake up the buffer process if necessary. */
+	debug("write waking");
+	if(xf->wakeme[XF_READER])
+	return xfermem_putcmd(xf->fd[XF_WRITER], XF_CMD_WAKEUP_INFO) < 0 ? TRUE : FALSE;
+
+	return FALSE;
+}
+
+#else /* stubs for generic / win32 */
+
+#include "mpg123app.h"
+#include "xfermem.h"
+
+void xfermem_init (txfermem **xf, size_t bufsize, size_t msize, size_t skipbuf)
+{
+}
+void xfermem_done (txfermem *xf)
+{
+}
+void xfermem_init_writer (txfermem *xf)
+{
+}
+void xfermem_init_reader (txfermem *xf)
+{
+}
+size_t xfermem_get_freespace (txfermem *xf)
+{
+  return 0;
+}
+size_t xfermem_get_usedspace (txfermem *xf)
+{
+  return 0;
+}
+int xfermem_write(txfermem *xf, byte *buffer, size_t bytes)
+{
+	return FALSE;
+}
+int xfermem_getcmd (int fd, int block)
+{
+  return 0;
+}
+int xfermem_putcmd (int fd, byte cmd)
+{
+  return 0;
+}
+int xfermem_block (int readwrite, txfermem *xf)
+{
+  return 0;
+}
+int xfermem_sigblock (int readwrite, txfermem *xf, int pid, int signal)
+{
+  return 0;
+}
+#endif
+
+/* eof */
+