Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdemultimedia@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 1543 insertions, 0 deletions

diff --git a/kscd/libwm/database.c b/kscd/libwm/database.c
new file mode 100644
index 00000000..f7f4e7cc
--- /dev/null
+++ b/kscd/libwm/database.c
@@ -0,0 +1,1543 @@
+/*
+ * $Id$
+ *
+ * This file is part of WorkMan, the civilized CD player library
+ * (c) 1991-1997 by Steven Grimm (original author)
+ * (c) by Dirk Försterling (current 'author' = maintainer)
+ * The maintainer can be contacted by his e-mail address:
+ * milliByte@DeathsDoor.com 
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *
+ * Manage the CD database.  All these routines assume that the "cd" global
+ * structure contains current information (as far as the outside world knows;
+ * obviously it won't contain track titles just after a CD is inserted.)
+ */
+
+#define RCFILE "/.workmanrc"
+#define DBFILE "/.workmandb"
+#define FUZZFRAMES 75
+
+#include <errno.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/time.h>
+#include <sys/stat.h>
+#include <time.h>
+#include "include/wm_config.h"
+#include "include/wm_helpers.h"
+#include "include/wm_struct.h"
+#include "include/wm_cdinfo.h"
+#include "include/wm_cddb.h"
+#include "include/wm_index.h"
+#include "include/wm_database.h"
+
+#define WM_MSG_CLASS WM_MSG_CLASS_DB
+
+#define SWALLOW_LINE(fp) { int _c; while ((_c = getc(fp)) != '\n' && _c != EOF); }
+
+/* local prototypes */
+char *print_cdinfo(struct wm_cdinfo *pcd, int prefs);
+FILE *open_rcfile(const char *name, const char *mode);
+int *reset_tracks(void);
+int search_db( FILE *fp, int prefs, int scan, int holesize_wanted );
+void spinwheels(int secs);
+int lockit(int fd, int type);
+void save_globals(FILE *fp);
+int save_entry(char *filename, int pref);
+/* local prototypes END */
+
+static int	suppress_locking = 0;	/* Turn off locking of datafile (dangerous) */
+
+static char	*rcfile = NULL;		/* Personal rcfile */
+static char	*dbfiles = NULL;	/* Colon-separated list of databases */
+static char	**databases = NULL;	/* NULL-terminated list of databases */
+
+static char	*otherrc = NULL;	/* Unrecognized cruft from start of rcfile */
+
+static long	rcpos, rclen;		/* XXX */
+
+static int	found_in_db, found_in_rc;
+static long	holepos, firstpos;
+
+static int fuzz_frames = FUZZFRAMES;
+
+static int wm_db_save_disabled = FALSE;
+
+static int cur_playnew = -1;
+
+extern int cur_ntracks, cur_nsections;
+
+int mark_a = 0;
+int mark_b = 0;
+
+
+/*
+ *
+ */
+int wm_db_get_playnew( void )
+{
+	return 0;
+}
+
+/*
+ * split_workmandb()
+ *
+ * Split the WORKMANDB environment variable, if any, into a list of database
+ * files in the global "databases".  If WORKMANDB is not available, make
+ * a single entry with $HOME/DBFILE.
+ *
+ * Also, fill the "rcfile" global with the personal preferences filename.
+ *
+ * The environment variables should have already been read and placed in the
+ * "rcfile" and "dbfiles" globals, respectively.
+ */
+void
+split_workmandb( void )
+{
+	int	ndbs, i;
+	char	*home, *wmdb;
+	int	no_rc = 0, no_db = 0;
+	
+	if (rcfile == NULL)
+	{
+		if ((home = getenv("HOME")) != NULL)
+		{
+			rcfile = malloc(strlen(home) + sizeof(RCFILE));
+			if (rcfile == NULL)
+			{
+			
+nomem:
+				perror("split_workmandb()");
+				exit(1);
+			}
+
+			strcpy(rcfile, home);
+			strcat(rcfile, RCFILE);
+		}
+		else
+			no_rc = 1;
+
+	}
+
+	if ((wmdb = dbfiles) == NULL)
+	{
+		if ((home = getenv("HOME")) != NULL)
+		{
+			wmdb = malloc(strlen(home) + sizeof(DBFILE));
+			if (wmdb == NULL)
+				goto nomem;
+
+			databases = malloc(2 * sizeof (databases[0]));
+			if (databases == NULL)
+				goto nomem;
+
+			strcpy(wmdb, home);
+			strcat(wmdb, DBFILE);
+			databases[0] = wmdb;
+			databases[1] = NULL;
+		}
+		else
+		{
+			static char *emptydb = NULL;
+		
+			databases = &emptydb;
+			no_db = 1;
+		}
+	}
+	else
+	{
+		ndbs = 1;
+		for (home = wmdb; *home; home++)
+			if (*home == ':')
+			{
+				*home = '\0';
+				ndbs++;
+			}
+		
+		databases = malloc((ndbs + 1) * sizeof(databases[0]));
+		if (databases == NULL)
+			goto nomem;
+		
+		for (i = 0; i < ndbs; i++)
+		{
+			databases[i] = wmdb;
+			wmdb += strlen(wmdb) + 1;
+		}
+
+		databases[i] = NULL;
+	}
+
+	if (no_db || no_rc)
+	{
+#ifndef NDEBUG
+		fprintf(stderr,
+"WorkMan was run without a home directory, probably by a system daemon.\n");
+		fprintf(stderr, "It doesn't know where to find ");
+		if (no_rc)
+		{
+			fprintf(stderr, "your personal preferences file ");
+			if (no_db)
+				fprintf(stderr, "or the\ndatabase of CD descriptions");
+		}
+		else
+			fprintf(stderr, "the database of CD descriptions");
+
+		fprintf(stderr,
+".\nYou can use the X resources \"workman.db.shared\" and \"workman.db.personal\"\nto tell WorkMan where to look.\n");
+#endif
+		wm_db_save_disabled = TRUE;
+	}
+}
+
+/*
+ * print_cdinfo(cd, prefs)
+ *
+ * cd		A pointer to a cdinfo struct.
+ * prefs	Flag: write personal preferences?
+ *
+ * Print a CD's information (in more or less readable form) to a buffer.
+ * Returns a pointer to the buffer.
+ *
+ * XXX - could be more efficient about calling wm_strmcat() and strlen().
+ */
+char *
+print_cdinfo(struct wm_cdinfo *cd, int prefs)
+{
+	int		i;
+	char		tempbuf[2000];	/* XXX - is this always big enough? */
+	static char	*cdibuf = NULL;
+	struct wm_playlist	*l;
+
+	sprintf(tempbuf, "\ntracks %d", cd->ntracks);
+	for (i = 0; i < cur_ntracks; i++)
+		if (cd->trk[i].section < 2)
+			sprintf(tempbuf + strlen(tempbuf), " %d",
+				cd->trk[i].start);
+	sprintf(tempbuf + strlen(tempbuf), " %d\n", cd->length);
+
+	wm_strmcpy(&cdibuf, tempbuf);
+
+	if (cur_nsections)
+	{
+		sprintf(tempbuf, "sections %d", cur_nsections);
+		/* fixed a bug here */
+		for (i = 0; i < cur_ntracks; i++)
+			if (cd->trk[i].section > 1)
+				sprintf(tempbuf + strlen(tempbuf), " %d",
+					cd->trk[i].start);
+		sprintf(tempbuf + strlen(tempbuf), "\n");
+
+		wm_strmcat(&cdibuf, tempbuf);
+	}
+
+	if (prefs)
+	{
+		if (cd->autoplay)
+			wm_strmcat(&cdibuf, "autoplay\n");
+		for (l = cd->lists; l != NULL && l->name != NULL; l++)
+		{
+			wm_strmcat(&cdibuf, "playlist ");
+
+			i = strlen(cdibuf) - 1;
+			wm_strmcat(&cdibuf, l->name);
+			while (cdibuf[++i])
+				if (cdibuf[i] == ' ' || cdibuf[i] == '\t')
+					cdibuf[i] = '_';
+
+			if (l->list != NULL)
+			{
+				for (i = 0; l->list[i]; i++)
+					;
+				sprintf(tempbuf, " %d", i);
+				wm_strmcat(&cdibuf, tempbuf);
+				for (i = 0; l->list[i]; i++)
+				{
+					sprintf(tempbuf, " %d", l->list[i]);
+					wm_strmcat(&cdibuf, tempbuf);
+				}
+				wm_strmcat(&cdibuf, "\n");
+			}
+			else
+				wm_strmcat(&cdibuf, " 0\n");
+		}
+
+		if (cd->volume)
+		{
+			/*
+			 * Have to maintain compatibility with old versions,
+			 * where volume was 0-32.
+			 */
+			sprintf(tempbuf, "cdvolume %d\n", (cd->volume * 32) / 100);
+			wm_strmcat(&cdibuf, tempbuf);
+		}
+
+		if (cd->playmode)
+		{
+			sprintf(tempbuf, "playmode %d\n", cd->playmode);
+			wm_strmcat(&cdibuf, tempbuf);
+		}
+
+		if (mark_a)
+		{
+			sprintf(tempbuf, "mark %d START\n", mark_a);
+			wm_strmcat(&cdibuf, tempbuf);
+		}
+		if (mark_b)
+		{
+			sprintf(tempbuf, "mark %d END\n", mark_b);
+			wm_strmcat(&cdibuf, tempbuf);
+		}
+
+		if (cd->otherrc)
+			wm_strmcat(&cdibuf, cd->otherrc);
+
+		for (i = 0; i < cur_ntracks; i++)
+		{
+			if (cd->trk[i].avoid)
+			{
+				sprintf(tempbuf, "dontplay %d\n", i + 1);
+				wm_strmcat(&cdibuf, tempbuf);
+			}
+			if (cd->trk[i].volume)
+			{
+				sprintf(tempbuf, "volume %d %d\n", i + 1,
+					(cd->trk[i].volume * 32) / 100);
+				wm_strmcat(&cdibuf, tempbuf);
+			}
+			if (cd->trk[i].otherrc)
+				wm_strmcat(&cdibuf, cd->trk[i].otherrc);
+		}
+	}
+	else
+	{
+		if (cd->cdname[0])
+		{
+			wm_strmcat(&cdibuf, "cdname ");
+			wm_strmcat(&cdibuf, cd->cdname);
+			wm_strmcat(&cdibuf, "\n");
+		}
+
+		if (cd->artist[0])
+		{
+			wm_strmcat(&cdibuf, "artist ");
+			wm_strmcat(&cdibuf, cd->artist);
+			wm_strmcat(&cdibuf, "\n");
+		}
+
+		if (cd->otherdb)
+			wm_strmcat(&cdibuf, cd->otherdb);
+
+		for (i = 0; i < cur_ntracks; i++)
+		{
+			if (cd->trk[i].section > 1)
+				wm_strmcat(&cdibuf, "s-");
+			wm_strmcat(&cdibuf, "track ");
+			if (cd->trk[i].songname != NULL)
+				wm_strmcat(&cdibuf, cd->trk[i].songname);
+			wm_strmcat(&cdibuf, "\n");
+			if (cd->trk[i].contd)
+			{
+				if (cd->trk[i].section > 1)
+					wm_strmcat(&cdibuf, "s-");
+				wm_strmcat(&cdibuf, "continue\n");
+			}
+			if (cd->trk[i].otherdb)
+				wm_strmcat(&cdibuf, cd->trk[i].otherdb);
+		}
+	}
+
+	return (cdibuf);
+} /* print_cdinfo() */
+
+/*
+ * Open the rcfile for reading or writing.
+ *
+ *	name		Filename
+ *	mode		"r" or "w"
+ */
+FILE *
+open_rcfile(const char *name, const char *mode)
+{
+	FILE		*fp;
+	struct stat	st;
+
+	fp = fopen(name, mode);
+	if (fp == NULL)
+	{
+		if (errno != ENOENT || mode[0] == 'w')
+			perror(name);
+	}
+	else
+	{
+		/* Don't let people open directories or devices */
+		if (fstat(fileno(fp), &st) < 0)
+		{
+			perror(name);
+			fclose(fp);
+			return (NULL);
+		}
+
+#ifdef S_ISREG
+		if (! S_ISREG(st.st_mode))
+#else
+		if ((st.st_mode & S_IFMT) != S_IFREG)
+#endif
+		{
+			errno = EISDIR;
+			perror(name);
+			fclose(fp);
+			return (NULL);
+		}
+
+		if (mode[0] == 'w') /* create -- put data in so locks work */
+		{
+			fputs("# WorkMan database file\n", fp);
+			fclose(fp);
+			fp = fopen(name, "r+");
+			if (fp == NULL)
+				if (errno != ENOENT)
+					perror(name);
+		}
+	}
+
+	return (fp);
+}
+
+/*
+ *
+ * allocate and clear "trackmap".
+ *
+ */
+int *reset_tracks(void)
+{
+    int i, j;
+    int *trackmap;
+    /*
+     * Since we access track numbers indirectly (to handle sections
+     * with at least a little elegance), the track mapping needs to be
+     * set up before we read anything.  Initially it must assume that
+     * no sections will appear in this datafile.
+     */
+    trackmap = malloc(sizeof(int) * cur_ntracks);
+    if (trackmap == NULL)
+    {
+    	perror("trackmap");
+	exit(1);
+    }
+    j = 0;
+    for (i = 0; i < cd->ntracks; i++)
+    {
+	trackmap[i] = j;
+	while (cd->trk[++j].section > 1)
+		;
+    }
+    return trackmap;
+} /* reset_tracks() */
+
+/*
+ * Load a new-format database file, searching for a match with the currently
+ * inserted CD.  Modify the in-core copy of the CD info based on what's found
+ * in the database.
+ *
+ * Returns 1 if there was a match or 0 if not.
+ *
+ *	fp		FILE* of database or rcfile.
+ *	prefs		1 if we're searching .workmanrc, 0 for .workmandb,
+ *			2 if just reading settings
+ *	scan		Scan for "tracks" location and entry size only
+ *	holesize_wanted	How big a hole we're looking for, if any.
+ *
+ * If a hole was found along the way, update the global "holepos" with its
+ * starting offset in the file.  A hole is defined as a bunch of blank lines
+ * preceding a "tracks" line.  Holepos will contain the best match.
+ *
+ * In addition, "firstpos" will be filled with the position of the first
+ * "tracks" keyword, so we know how much room is available for global
+ * settings at the rcfile's start.
+ */
+int
+search_db( FILE *fp, int prefs, int scan, int holesize_wanted )
+
+{
+	char	keyword[64], listname[64], *c;
+	int	b, i, j, track = 0, listsize, ntracks, scratch, searching = 1;
+	int	*trackmap = 0, gotsections = 0;
+        int     fudge, maxfudge, sizediff, bestfudge = 0;
+	long	pos = 0, thisholepos = -1, holesize = 99991239;
+	struct	wm_playlist *l;
+
+	rclen = 0;
+
+	wm_lib_message(WM_MSG_CLASS_DB|WM_MSG_LEVEL_DEBUG , "db: Reached search_db()\n" );
+
+	/* We may not find any holes at all! */
+	if (holesize_wanted)
+		holepos = -1;
+
+	if( prefs != 2 )
+		trackmap = reset_tracks();
+
+	if (prefs)
+		freeup(&otherrc);
+	firstpos = -1;
+	while (! feof(fp))
+	{
+		pos = ftell(fp);
+		keyword[0] = '\0';
+		do
+			b = getc(fp);
+		while (b != EOF && b != '\n' && isspace(b));
+
+		if (b == EOF || feof(fp))
+			break;
+
+		if (b != '\n')
+		{
+			keyword[0] = b;
+			fscanf(fp, "%62s", &keyword[1]);
+		}
+		if (keyword[0] == '\0')		/* Blank line. */
+		{
+			if (thisholepos < 0)
+				thisholepos = pos;
+			continue;
+		}
+
+		/* Strip off "s-" if we've seen a "sections" keyword */
+		if (gotsections && keyword[0] == 's' && keyword[1] == '-')
+		{
+			for (c = &keyword[2]; (c[-2] = *c) != '\0'; c++)
+				;
+			wm_lib_message(WM_MSG_CLASS_DB|WM_MSG_LEVEL_DEBUG , "db: stripped off the 's-'. Result is %s\n", keyword);
+		}
+
+		/* If this is the start of a CD entry, see if it matches. */
+		if (! strcmp(keyword, "tracks"))
+		{
+			if (prefs == 2)
+				break;
+
+			/* Is this the end of a hole? */
+			if (holesize_wanted && (thisholepos >= 0))
+			{
+				/* Yep.  Is it better than the last one? */
+				if (pos - thisholepos < holesize && pos -
+						thisholepos >= holesize_wanted)
+				{
+					holepos = thisholepos;
+					holesize = pos - thisholepos;
+				}
+				thisholepos = -1;
+			}
+
+			/* Is it the start of the CD entries? */
+			if (firstpos == -1)
+				firstpos = pos;
+
+			/* Is this the end of the entry we really wanted? */
+			if (! searching)
+			{
+				rclen = pos - rcpos;
+				break;
+			}
+
+                        /* If we have a near match, indicate that we
+                            should stop reading tracks, etc now */
+                        if (searching == 2)
+                        {
+                            searching = 3;
+                            continue;
+                        }
+
+			fscanf(fp, "%d", &ntracks);
+
+			if (ntracks != cd->ntracks)
+			{
+chomp:
+				SWALLOW_LINE(fp);
+				continue;
+			}
+
+                        fudge = 0;
+                        maxfudge = (ntracks * fuzz_frames) >> 1;
+			track = 0;
+			for (i = 0; i < ntracks; i++)
+			{
+				fscanf(fp, "%d", &scratch);
+				if (scratch != cd->trk[track].start)
+                                {
+                                    sizediff = abs(scratch - cd->trk[track].start);
+                                    if (sizediff > fuzz_frames || 
+                                        (sizediff && scan))
+                                      break;
+                                    fudge += sizediff;
+                                }
+				while (cd->trk[++track].section > 1)
+					;
+			}
+			if (i != ntracks)
+				goto chomp;
+
+                        if (fudge > 0) /* best near match? */
+                        {
+                            if (fudge > maxfudge)
+                                goto chomp;
+                            if (bestfudge == 0 || fudge < bestfudge)
+                                bestfudge = fudge;
+                            else
+                                goto chomp;
+			    rcpos = pos;
+			    track = 0;
+                            searching = 2;
+                        }
+                        else /* probably exact match */
+                        {
+			    fscanf(fp, "%d", &scratch);
+
+			    if (scratch != -1 && scratch != cd->length)
+				    goto chomp;
+
+			    /* Found it! */
+			    rcpos = pos;
+			    track = 0;
+			    searching = 0;
+                        }
+
+			SWALLOW_LINE(fp);	/* Get rid of newline */
+		}
+
+		/* Global mode stuff goes here */
+		else if (! strcmp(keyword, "cddbprotocol"))
+		{
+			getc(fp);
+			i = getc(fp);	/* only first letter is used */
+		        cddb.protocol = i == 'c' ? 1 : 
+		                        i == 'h' ? 2 : 3 ;
+			do
+				i = getc(fp);
+			while (i != '\n' && i != EOF);
+		}
+
+		else if (! strcmp(keyword, "cddbserver"))
+		{
+			getc(fp);	/* lose the space */
+			if (cddb.cddb_server[0])
+				do
+					i = getc(fp);
+				while (i != '\n' && i != EOF);
+			else
+			{
+				fgets(cddb.cddb_server, 
+				      sizeof(cddb.cddb_server), fp);
+				if ((i = strlen(cddb.cddb_server)))
+					cddb.cddb_server[i - 1] = '\0';
+			}
+		}
+
+		else if (! strcmp(keyword, "cddbmailadress"))
+		{
+			getc(fp);	/* lose the space */
+			if (cddb.mail_adress[0])
+				do
+					i = getc(fp);
+				while (i != '\n' && i != EOF);
+			else
+			{
+				fgets(cddb.mail_adress, 
+				      sizeof(cddb.mail_adress), fp);
+				if ((i = strlen(cddb.mail_adress)))
+					cddb.mail_adress[i - 1] = '\0';
+			}
+		}
+
+		else if (! strcmp(keyword, "cddbpathtocgi"))
+		{
+			getc(fp);	/* lose the space */
+			if (cddb.path_to_cgi[0])
+				do
+					i = getc(fp);
+				while (i != '\n' && i != EOF);
+			else
+			{
+				fgets(cddb.path_to_cgi, 
+				      sizeof(cddb.path_to_cgi), fp);
+				if ((i = strlen(cddb.path_to_cgi)))
+					cddb.path_to_cgi[i - 1] = '\0';
+			}
+		}
+
+		else if (! strcmp(keyword, "cddbproxy"))
+		{
+			getc(fp);	/* lose the space */
+			if (cddb.proxy_server[0])
+				do
+					i = getc(fp);
+				while (i != '\n' && i != EOF);
+			else
+			{
+				fgets(cddb.proxy_server, 
+				      sizeof(cddb.proxy_server), fp);
+				if ((i = strlen(cddb.proxy_server)))
+					cddb.proxy_server[i - 1] = '\0';
+			}
+		}
+
+		else if (! strcmp(keyword, "whendone"))
+		{
+			getc(fp);
+			i = getc(fp);	/* only first letter is used */
+			if (cur_stopmode == -1)	/* user's setting preferred */
+				cur_stopmode = i == 's' ? 0 : i == 'r' ? 1 : 2;
+			do
+				i = getc(fp);
+			while (i != '\n' && i != EOF);
+		}
+
+		else if (! strcmp(keyword, "playnew"))
+		{
+			if (cur_playnew == -1)
+				cur_playnew = 1;
+			SWALLOW_LINE(fp);
+		}
+
+		/* If we're searching, skip to the next "tracks" line. */
+		else if (((searching & 1)|| scan) 
+                         && !(prefs && firstpos == -1))
+			SWALLOW_LINE(fp)
+
+		else if (! strcmp(keyword, "sections"))
+		{
+			gotsections = 1;
+			fscanf(fp, "%d", &ntracks);
+
+			free(trackmap);
+			trackmap = (int *) malloc(sizeof(int) *
+						(cur_ntracks + ntracks));
+			if (trackmap == NULL)
+			{
+				perror("section mapping");
+				exit(1);
+			}
+
+			/*
+			 * If sections are already defined, use these as a
+			 * reference, mapping this CD entry's section numbers
+			 * to the ones in core.
+			 *
+			 * Otherwise, split the CD up according to the sections
+			 * listed here.
+			 */
+			if (cur_nsections)
+			{
+				track = 0;
+				i = 0;
+				while (ntracks)
+				{
+					ntracks--;
+					fscanf(fp, "%d", &scratch);
+					while (scratch > cd->trk[track].start)
+					{
+						if (cd->trk[track].section < 2)
+							trackmap[i++] = track;
+						++track;
+
+						if (track == cur_ntracks)
+							break;
+					}
+
+					/* rc has later sections than db... */
+					if (track == cur_ntracks)
+						break;
+
+					/* Matches can be approximate */
+					if (scratch+75 > cd->trk[track].start &&
+					    scratch-75 < cd->trk[track].start)
+						trackmap[i++] = track++;
+					else
+						trackmap[i++] = -1;
+					
+					if (track == cur_ntracks)
+						break;
+				}
+
+				/* This only happens if track == cur_ntracks */
+				while (ntracks--)
+					trackmap[i++] = -1;
+
+				while (track < cur_ntracks)
+				{
+					if (cd->trk[track].section < 2)
+						trackmap[i++] = track;
+					track++;
+				}
+
+				track = 0;
+				SWALLOW_LINE(fp);
+			}
+			else
+			{
+				while (ntracks--)
+				{
+					fscanf(fp, "%d", &scratch);
+					split_trackinfo(scratch);
+				}
+
+				for (i = 0; i < cur_ntracks; i++)
+				{
+					trackmap[i] = i;
+					/* split_trackinfo() sets this */
+					cd->trk[i].contd = 0;
+				}
+
+				SWALLOW_LINE(fp);
+			}
+		}
+
+		else if (! strcmp(keyword, "track"))
+		{
+			char buf[502];
+
+			getc(fp);	/* lose the space */
+
+			/* don't overwrite existing track names. */
+			/* However, overwrite them if there was a "bad" fuzzy match before */
+			if ((trackmap[track] == -1 || track > (cd->ntracks + cur_nsections)) && (searching == 2))
+				SWALLOW_LINE(fp)
+			else if (cd->trk[trackmap[track]].songname &&
+					cd->trk[trackmap[track]].songname[0])
+				do
+					i = getc(fp);
+				while (i != '\n' && i != EOF);
+			else
+			{
+				fgets(buf, sizeof(buf), fp);
+				wm_lib_message(WM_MSG_CLASS_DB|WM_MSG_LEVEL_DEBUG, "found track %s\n", buf);
+				if( (i = strlen(buf)) )
+					buf[i - 1] = '\0';
+				wm_strmcpy(&cd->trk[trackmap[track]].songname, buf);
+			}
+			track++;
+		}
+
+		else if (! strcmp(keyword, "playmode"))
+			fscanf(fp, "%d", &cd->playmode);
+
+		else if (! strcmp(keyword, "autoplay"))
+			cd->autoplay = 1;
+
+		else if (! strcmp(keyword, "cdname"))
+		{
+                        /* because of fuzzy matching that may change
+                           the disk contents, we reset everything when
+                           we find the name, in hopes that we will recover
+                           most, if not all, of the information from the
+                           file. */
+/*
+ * nasty bug was here. Was it? BUGBUGBUG
+ *
+ *			 wipe_cdinfo(); 
+ *			 trackmap = reset_tracks();
+ */
+
+			getc(fp);	/* lose the space */
+			/* don't overwrite existing cd name. */
+			if (cd->cdname[0] && (searching == 2))
+				do
+					i = getc(fp);
+				while (i != '\n' && i != EOF);
+			else
+			{
+                                if (searching > 1)
+                                {
+                                    strcpy(cd->cdname, "Probably://");
+				    fgets(cd->cdname + strlen(cd->cdname), sizeof(cd->cdname), fp);
+                                } 
+                                else 
+                                {
+				    fgets(cd->cdname, sizeof(cd->cdname), fp);
+                                } 
+				if ( (i = strlen(cd->cdname)) )
+					cd->cdname[i - 1] = '\0';
+			}
+		}
+
+		else if (! strcmp(keyword, "artist"))
+		{
+			getc(fp);	/* lose the space */
+			/* don't overwrite existing artist names. */
+			if (cd->artist[0])
+				do
+					i = getc(fp);
+				while (i != '\n' && i != EOF);
+			else
+			{
+				fgets(cd->artist, sizeof(cd->artist), fp);
+				if( (i = strlen(cd->artist)) )
+					cd->artist[i - 1] = '\0';
+			}
+		}
+
+		else if (! strcmp(keyword, "cdvolume"))
+		{
+			fscanf(fp, "%d", &cd->volume);
+			cd->volume = (cd->volume * 100) / 32;
+		}
+
+		else if (! strcmp(keyword, "dontplay"))
+		{
+			fscanf(fp, "%d", &i);
+			if (trackmap[i - 1] != -1)
+				cd->trk[trackmap[i - 1]].avoid = 1;
+		}
+
+		else if (! strcmp(keyword, "continue"))
+		{
+			if (trackmap[track - 1] != -1)
+				cd->trk[trackmap[track - 1]].contd = 1;
+		}
+
+		else if (! strcmp(keyword, "volume"))
+		{
+			fscanf(fp, "%d", &i);
+			if (trackmap[i - 1] == -1)
+				SWALLOW_LINE(fp)
+			else
+			{
+				i = trackmap[i - 1];
+				fscanf(fp, "%d", &cd->trk[i].volume);
+				cd->trk[i].volume = (cd->trk[i].volume*100)/32;
+				if (cd->trk[i].volume > 32)
+					cd->trk[i].volume = 0;
+			}
+		}
+
+		else if (! strcmp(keyword, "playlist"))
+		{
+			getc(fp);
+			fscanf(fp, "%63s", listname);
+
+/* XXX take this out at some point */
+			if (! strcmp(listname, "Default"))
+				strcpy(listname, "List A");
+
+			for (i = 0; listname[i]; i++)
+				if (listname[i] == '_')
+					listname[i] = ' ';
+
+			l = new_playlist(cd, listname);
+			if (l == NULL)
+			{
+plnomem:
+				perror("playlist read");
+				exit(1);
+			}
+
+			fscanf(fp, "%d", &listsize);
+
+			l->list = malloc(sizeof(int) * (listsize + 1));
+			if (l->list == NULL)
+				goto plnomem;
+
+			/* Leave out tracks that weren't in .workmandb. */
+			j = 0;
+			for (i = 0; i < listsize; i++)
+			{
+				fscanf(fp, "%d", &scratch);
+				scratch = trackmap[scratch - 1];
+				if (scratch != -1)
+					l->list[j++] = scratch + 1;
+			}
+
+			l->list[j] = 0;
+		}
+
+		else if (! strcmp(keyword, "mark"))
+		{
+			int mark_val = -1, mark_namelen;
+			char mark_name[32];
+
+			fscanf(fp, "%d", &mark_val);
+			if (mark_val == -1)
+				goto chomp;
+
+			if (getc(fp) != ' ')
+				continue;
+
+			fgets(mark_name, sizeof(mark_name), fp);
+			if( ( mark_namelen = strlen(mark_name)) )
+				mark_name[mark_namelen - 1] = '\0';
+
+/*
+			if (! strcmp(mark_name, "START"))
+				set_abtimer(0, mark_val);
+			else if (! strcmp(mark_name, "END"))
+				set_abtimer(1, mark_val);
+
+*/
+		}
+
+		/* Unrecognized keyword.  Put it in the right place. */
+		else
+		{
+			char	**buf, input[BUFSIZ];
+
+			if (track && trackmap[track - 1] == -1)
+			{
+				SWALLOW_LINE(fp);
+				continue;
+			}
+
+			i = track ? trackmap[track - 1] : 0;
+			buf = prefs ? i ? &cd->trk[i].otherrc : &cd->otherrc :
+				i ? &cd->trk[i].otherdb : &cd->otherdb;
+			if (firstpos == -1) {
+				if (prefs) {
+					buf = &otherrc;
+				} else {
+					goto chomp;
+				} /* if() else */
+                        } /* if() */
+			wm_strmcat(buf, keyword);
+			do {
+				input[sizeof(input) - 1] = 'x';
+				fgets(input, sizeof(input), fp);
+				wm_strmcat(buf, input);
+			} while (input[sizeof(input) - 1] != 'x');
+		}
+	}
+
+	if (rclen == 0 && !searching)
+		rclen = pos - rcpos;
+
+        if (searching > 1) /* A near match has been found. Good enough. */
+            searching = 0;
+
+        cddb_struct2cur();
+	return (! searching);
+
+} /* search_db() */
+
+/*
+ * Delay some amount of time without using interval timers.
+ */
+void
+spinwheels(int secs) {
+	struct timeval	tv;
+
+	tv.tv_usec = 0;
+	tv.tv_sec = secs;
+	select(0, NULL, NULL, NULL, &tv);
+} /* spinwheels() */
+
+/*
+ * lockit(fd, type)
+ *
+ * fd    file descriptor
+ * type  lock type
+ *
+ * Lock a file.  Time out after a little while if we can't get a lock;
+ * this usually means the locking system is broken.
+ *
+ * Unfortunately, if there are lots of people contending for a lock,
+ * this can result in the file not getting locked when it probably should.
+ */
+int
+lockit(int fd, int type)
+{
+	struct flock	fl;
+	int		result, timer = 0;
+
+	if (suppress_locking)
+		return (0);
+
+	fl.l_type = type;
+	fl.l_whence = 0;
+	fl.l_start = 0;
+	fl.l_len = 0;
+
+	while ((result = fcntl(fd, F_SETLK, &fl)) < 0)
+	{
+		if (errno != EACCES || errno != EAGAIN)
+			break;
+		if (timer++ == 30)
+		{
+			errno = ETIMEDOUT;
+			break;
+		}
+
+		spinwheels(1);
+	}
+
+	return (result);
+} /* lockit() */
+
+/*
+ * Search all the database files and our personal preference file for
+ * more information about the current CD.
+ */
+void
+load( void )
+{
+	FILE		*fp;
+	char		**dbfile;
+	int		locked = 0;
+	int		dbfound = 0, *trklist, i;
+	unsigned long	dbpos;
+
+/* This is some kind of profiling code. I don't change it
+   to wm_lib_message() for now... */
+#ifndef NDEBUG
+	long		t1, t2;
+	if( getenv( "WORKMAN_DEBUG" ) != NULL )
+	  {
+		time(&t1);
+		printf("%s (%d): search start = %ld\n", __FILE__, __LINE__, t1);
+        fflush(stdout);
+	  }	
+#endif
+
+	dbfile = databases;
+
+	found_in_db = 0;
+
+	/* Turn the cd->trk array into a simple array of ints. */
+	trklist = (int *)malloc(sizeof(int) * cd->ntracks);
+	for (i = 0; i < cd->ntracks; i++)
+		trklist[i] = cd->trk[i].start;
+
+	do {
+		if (*dbfile && idx_find_entry(*dbfile, cd->ntracks, trklist,
+				cd->length * 75, 0, &dbpos) == 0)
+			dbfound = 1;
+
+		fp = *dbfile ? open_rcfile(*dbfile, "r") : NULL;
+		if (fp != NULL)
+		{
+			if (lockit(fileno(fp), F_RDLCK))
+				perror("Couldn't get read (db) lock");
+			else
+				locked = 1;
+
+			if (dbfound)
+				fseek(fp, dbpos, 0);
+
+			if (search_db(fp, 0, 0, 0))
+			{
+				found_in_db = 1;
+				cd->whichdb = *dbfile;
+			}
+
+			if (locked && lockit(fileno(fp), F_UNLCK))
+				perror("Couldn't relinquish (db) lock");
+
+			fclose(fp);
+		}
+	} while (*++dbfile != NULL && cd->whichdb == NULL);
+
+#ifndef NDEBUG
+	if( getenv( "WORKMAN_DEBUG" ) != NULL )
+	  {
+		time(&t2);
+		printf("%s (%d): db search end = %ld, elapsed = %ld\n", __FILE__, __LINE__, t2, t2 - t1);
+		fflush(stdout);
+	  }	
+#endif
+
+	fp = rcfile ? open_rcfile(rcfile, "r") : NULL;
+	if (fp != NULL)
+	{
+		locked = 0;
+		if (lockit(fileno(fp), F_RDLCK))
+			perror("Couldn't get read (rc) lock");
+		else
+			locked = 1;
+
+		rcpos = 0;
+		found_in_rc = search_db(fp, 1, 0, 0);
+		if (! found_in_rc)
+			cd->autoplay = wm_db_get_playnew();
+
+		if (locked && lockit(fileno(fp), F_UNLCK))
+			perror("Couldn't relinquish (rc) lock");
+
+		fclose(fp);
+	}
+
+	free(trklist);
+
+	if (cur_playnew == -1)
+		cur_playnew = 0;
+
+#ifndef NDEBUG
+	if( getenv( "WORKMAN_DEBUG" ) != NULL )
+	  {
+		time(&t2);
+		printf("%s (%d): search end = %ld, elapsed = %ld\n", __FILE__, __LINE__, t2, t2 - t1);
+		fflush(stdout);
+	  }	
+#endif
+} /* load() */
+
+/*
+ * Load program settings from the rcfile.
+ */
+void
+load_settings( void )
+{
+	FILE    *fp;
+	int     locked;
+
+	fp = rcfile ? open_rcfile(rcfile, "r") : NULL;
+	if (fp != NULL)
+	{
+		locked = 0;
+		if (lockit(fileno(fp), F_RDLCK))
+			perror("Couldn't get read (rc) lock");
+		else
+			locked = 1;
+
+		rcpos = 0;
+		found_in_rc = search_db(fp, 2, 0, 0);
+		if (! found_in_rc)
+			cd->autoplay = wm_db_get_playnew();
+
+		if (locked && lockit(fileno(fp), F_UNLCK))
+			perror("Couldn't relinquish (rc) lock");
+
+		fclose(fp);
+	}
+} /* load_settings() */
+
+/*
+ * save_globals()
+ *
+ * Save the global preferences, scooting CD entries to the end if needed.
+ * The assumption here is that the rcfile is locked, and that firstpos has
+ * been set by a previous scan.
+ */
+void
+save_globals(FILE *fp)
+{
+	char	*globes = NULL, *cdentry = NULL, temp[100];
+	long	curpos;
+	int	globesize, hit_cdent = 0, c = 0;
+
+	if (otherrc)
+		wm_strmcpy(&globes, otherrc);
+
+	if (cddb.protocol)
+	{
+		sprintf(temp, "cddbprotocol ");
+		switch(cddb.protocol)
+		{
+		 case 1: /* cddbp */
+		    sprintf(temp + strlen(temp), "cddbp\n");
+		    break;
+		 case 2: /* http */
+		    sprintf(temp + strlen(temp), "http\n");
+		    break;
+		 case 3: /* proxy */
+		    sprintf(temp + strlen(temp), "proxy\n");
+		    break;
+		 default:
+		    break;
+		}
+		wm_strmcat(&globes, temp);
+	    
+		if(cddb.mail_adress[0])
+	 	{
+			sprintf(temp,"cddbmailadress %s\n",
+				cddb.mail_adress);
+			wm_strmcat(&globes, temp);
+		}
+
+		if(cddb.cddb_server[0])
+	 	{
+			sprintf(temp,"cddbserver %s\n",
+				cddb.cddb_server);
+			wm_strmcat(&globes, temp);
+		}
+
+		if(cddb.path_to_cgi[0])
+	 	{
+			sprintf(temp,"cddbpathtocgi %s\n",
+				cddb.mail_adress);
+			wm_strmcat(&globes, temp);
+		}
+
+		if(cddb.proxy_server[0])
+	 	{
+			sprintf(temp,"cddbproxy %s\n",
+				cddb.mail_adress);
+			wm_strmcat(&globes, temp);
+		}
+	}
+
+	if (cur_stopmode == 1 || cur_stopmode == 2)
+	{
+		sprintf(temp, "whendone %s\n", cur_stopmode == 1 ? "repeat" :
+			"eject");
+		wm_strmcat(&globes, temp);
+	}
+
+	if (cur_playnew == 1)
+		wm_strmcat(&globes, "playnew\n");
+
+	curpos = firstpos;
+	if (curpos < 0)
+		curpos = 0;
+
+	fseek(fp, curpos, SEEK_SET);
+
+	if (firstpos < (globesize = globes != NULL ? strlen(globes) : 0))
+	{
+		while (1)
+		{
+			temp[sizeof(temp)-1] = 'x';
+
+			if (fgets(temp, sizeof(temp), fp) == NULL)
+			{
+				fseek(fp, 0, SEEK_SET);
+				if (globes != NULL)
+				{
+					fwrite(globes, globesize, 1, fp);
+					free(globes);
+				}
+				if (cdentry != NULL)
+				{
+					fwrite(cdentry, strlen(cdentry), 1, fp);
+					free(cdentry);
+				}
+				return;
+			}
+
+			if (! strncmp(temp, "tracks ", 7))
+			{
+				hit_cdent = 1;
+				if (curpos >= globesize)
+					break;
+			}
+
+			if (! hit_cdent)
+			{
+				curpos += strlen(temp);
+				if (temp[sizeof(temp)-1] == '\0')
+					while ((c = getc(fp)) != '\n' &&
+								c != EOF)
+						curpos++;
+				if (c == '\n')
+					curpos++;
+
+				continue;
+			}
+
+			wm_strmcat(&cdentry, temp);
+			curpos += strlen(temp);
+			while (temp[sizeof(temp)-1] == '\0')
+			{
+				temp[sizeof(temp)-1] = 'x';
+				if (fgets(temp, sizeof(temp), fp) == NULL)
+					break;
+				wm_strmcat(&cdentry, temp);
+				curpos += strlen(temp);
+			}
+		} 
+
+		if (cdentry != NULL)
+		{
+			fseek(fp, 0, SEEK_END);
+			fwrite(cdentry, strlen(cdentry), 1, fp);
+			free(cdentry);
+		}
+	}
+
+	if (globes != NULL)
+	{
+		fseek(fp, 0, SEEK_SET);
+		fwrite(globes, globesize, 1, fp);
+		free(globes);
+	}
+
+	while (globesize++ < curpos)
+		putc('\n', fp);
+} /* save_globals() */
+
+/*
+ * save_entry()
+ *
+ * Save the CD information to one database.
+ *
+ *	filename	Database to save to.
+ *	pref		0 for hard data, 1 for preferences.
+ *
+ * If an entry for this CD exists already, overwrite it with the new entry
+ * if the new entry is the same size or smaller, or with newlines if the new
+ * entry is larger (in which case the new entry is appended to the file.)
+ *
+ * Also, if the preference information is being updated, save it to the
+ * file while we've got it locked.  Scoot stuff from the beginning of
+ * the file to the end as needed to facilitate this.
+ *
+ * XXX Preference-saving should probably be done elsewhere, like in an
+ * Apply button on the Goodies popup, and in any case needs to go to a
+ * different file (.Xdefaults?)
+ *
+ * Returns 0 on success.
+ */
+int
+save_entry(char *filename, int pref)
+{
+	FILE		*fp;
+	char		*buf;
+	int		len, i, locked = 0;
+
+
+	if( filename == NULL )
+		return (-1);
+
+	fp = open_rcfile(filename, "r+");
+	if (fp == NULL)
+	{
+		if (errno == ENOENT)	/* doesn't exist already */
+			fp = open_rcfile(filename, "w");
+		if (fp == NULL)
+			return (-1);
+	}
+
+	if (lockit(fileno(fp), F_WRLCK))
+		perror("Warning: Couldn't get write lock");
+	else
+		locked = 1;
+
+	buf = print_cdinfo(cd, pref);
+	len = strlen(buf);	/* doesn't return if there's an error */
+
+	rcpos = -1;
+	search_db(fp, pref, 1, len);
+	if (rcpos != -1)		/* XXX */
+	{
+		/*
+		 * Jump to the entry's position in the database file, if
+		 * it was found.
+		 */
+		fseek(fp, rcpos, SEEK_SET);
+
+		if (rclen >= len && holepos == -1)
+		{
+			/*
+			 * If the new entry will fit in the space occupied by
+			 * the old one, overwrite the old one and make a hole
+			 * of the appropriate size at its end.
+			 *
+			 * No need to update the index file in this case, as
+			 * the entry's position hasn't changed.
+			 */
+			fputs(buf, fp);
+			for (i = len; i < rclen; i++)
+				fputc('\n', fp);
+		}
+		else
+		{
+			/*
+			 * Overwrite the old entry with a hole and delete
+			 * its pointer in the index file.
+			 */
+			for (i = 0; i < rclen; i++)
+				fputc('\n', fp);
+			idx_delete_entry(filename, cd->trk[cd->ntracks-1].start,
+					0, rcpos);
+
+			rcpos = -1;
+		}
+	}
+
+	/*
+	 * Old entry wasn't found, or its new version wouldn't fit where
+	 * the old one was.
+	 */
+	if (rcpos == -1)
+	{
+		/*
+		 * Write the new entry in a hole, if there is one,
+		 * or at the end of the file.
+		 */
+		if (holepos >= 0)
+		{
+			fseek(fp, holepos, SEEK_SET);
+			if (holepos < firstpos)
+				firstpos = holepos;
+		}
+		else
+		{
+			fseek(fp, 0, SEEK_END);
+			holepos = ftell(fp);
+		}
+		fputs(buf, fp);
+
+		/*
+		 * Write a new index entry for this CD.
+		 */
+		idx_write_entry(filename, cd->trk[cd->ntracks - 1].start,
+			holepos);
+	}
+
+	if (pref)
+		save_globals(fp);
+
+	fflush(fp);
+
+	if (locked && lockit(fileno(fp), F_UNLCK))
+		perror("Warning: Couldn't relinquish write lock");
+
+	fclose(fp);
+
+	return (0);
+} /* save_entry() */
+
+/*
+ * save()
+ *
+ * Save CD information to the appropriate datafile (the first file in the
+ * list, unless the entry came from another database file) and to the
+ * personal prefs file.
+ */
+int
+save( void )
+{
+
+	if( wm_db_save_disabled == FALSE )
+	{
+		if (save_entry(rcfile, 1))
+			return (0);
+
+		if (cd->whichdb == NULL || access(cd->whichdb, W_OK))
+			cd->whichdb = databases[0];
+
+		if (save_entry(cd->whichdb, 0))
+			return (0);
+
+		return( WM_DB_SAVE_ERROR );
+	} else {
+		return( WM_DB_SAVE_DISABLED );
+	}
+} /* save() */