New directory for cross-platform development files (wrappers, etc).

src/xpdev/conwrap.c

+/*
+	conwrap.c -- To give DOS's getch() function to Linux for use in Synchronet
+    Casey Martin 2000
+*/
+
+/* $Id$ */
+
+/* @format.tab-size 4, @format.use-tabs true */
+
+#ifdef __unix__
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <termios.h>
+
+/* Do the correct thing under BSD */
+#ifndef __FreeBSD__
+#include <sys/kd.h>
+#endif
+#ifdef __FreeBSD__
+#include <sys/kbio.h>
+#endif
+
+#include <sys/time.h>
+#include <sys/types.h>
+#include <signal.h>
+
+#include "conwrap.h"	// Verify prototypes
+
+struct termios current;            // our current term settings
+struct termios original;           // old termios settings
+struct timeval timeout = {0, 0};   // passed in select() call
+fd_set inp;                        // ditto
+int beensetup = 0;                 // has _termios_setup() been called?
+
+/*
+	I'm using a variable function here simply for the sake of speed.  The
+    termios functions must be called before a kbhit() can be successful, so
+    on the first call, we just set up the terminal, point to variable function
+    to kbhit_norm(), and then call the new function.  Otherwise, testing would
+	be required on every call to determine if termios has already been setup.
+
+    Maybe I'm being way too anal, though.
+*/
+
+/* Resets the termios to its previous state */
+void _termios_reset(void)
+{
+	tcsetattr(0, TCSANOW, &original);
+}
+
+/************************************************
+  This pair of functions handles Ctrl-Z presses
+************************************************/
+
+void _sighandler_stop(int sig)
+{
+    // clean up the terminal
+    _termios_reset();
+
+    // ... and stop
+	kill(getpid(), SIGSTOP);
+}
+
+void _sighandler_cont(int sig)
+{
+    // restore terminal
+	tcsetattr(0, TCSANOW, &current);
+}
+
+
+/* Prepares termios for non-blocking action */
+void _termios_setup(void)
+{
+	beensetup = 1;
+    
+	tcgetattr(0, &original);
+  
+	memcpy(&current, &original, sizeof(struct termios));
+	current.c_cc[VMIN] = 1;           // read() will return with one char
+	current.c_cc[VTIME] = 0;          // read() blocks forever
+	current.c_lflag &= ~ICANON;       // character mode
+    current.c_lflag &= ~ECHO;         // turn off echoing
+	tcsetattr(0, TCSANOW, &current);
+
+    // Let's install an exit function, also.  This way, we can reset
+    // the termios silently
+    atexit(_termios_reset);
+
+    // install the Ctrl-Z handler
+    signal(SIGSTOP, _sighandler_stop);
+    signal(SIGCONT, _sighandler_cont);
+}
+
+
+int kbhit(void)
+{
+	// set up select() args
+	FD_ZERO(&inp);
+	FD_SET(0, &inp);
+
+	return select(1, &inp, NULL, NULL, &timeout);
+}
+
+int getch(void)
+{
+	char c;
+
+    if (!beensetup)
+    	// I hate to test for this every time, but this shouldn't be
+        // called that often anyway...
+    	_termios_setup();
+
+    // get a char out of stdin
+    read(0, &c, 1);
+
+    return c;
+}
+
+#endif // __unix__

src/xpdev/conwrap.h

+/* conwrap.h */
+
+/* Synchronet local console I/O wrapppers */
+
+/* $Id$ */
+
+/****************************************************************************
+ * @format.tab-size 4		(Plain Text/Source Code File Header)			*
+ * @format.use-tabs true	(see http://www.synchro.net/ptsc_hdr.html)		*
+ *																			*
+ * Copyright 2000 Rob Swindell - http://www.synchro.net/copyright.html		*
+ *																			*
+ * This program is free software; you can redistribute it and/or			*
+ * modify it under the terms of the GNU General Public License				*
+ * as published by the Free Software Foundation; either version 2			*
+ * of the License, or (at your option) any later version.					*
+ * See the GNU General Public License for more details: gpl.txt or			*
+ * http://www.fsf.org/copyleft/gpl.html										*
+ *																			*
+ * Anonymous FTP access to the most recent released source is available at	*
+ * ftp://vert.synchro.net, ftp://cvs.synchro.net and ftp://ftp.synchro.net	*
+ *																			*
+ * Anonymous CVS access to the development source and modification history	*
+ * is available at cvs.synchro.net:/cvsroot/sbbs, example:					*
+ * cvs -d :pserver:anonymous@cvs.synchro.net:/cvsroot/sbbs login			*
+ *     (just hit return, no password is necessary)							*
+ * cvs -d :pserver:anonymous@cvs.synchro.net:/cvsroot/sbbs checkout src		*
+ *																			*
+ * For Synchronet coding style and modification guidelines, see				*
+ * http://www.synchro.net/source.html										*
+ *																			*
+ * You are encouraged to submit any modifications (preferably in Unix diff	*
+ * format) via e-mail to mods@synchro.net									*
+ *																			*
+ * Note: If this box doesn't appear square, then you need to fix your tabs.	*
+ ****************************************************************************/
+
+#ifndef _CONWRAP_H
+#define _CONWRAP_H
+
+#ifdef __unix__
+
+	int kbhit(void);
+	int getch(void);
+
+#else	/* DOS-Based */
+
+	#include <conio.h>
+
+#endif
+
+#endif	/* _CONWRAP_H */

src/xpdev/dirwrap.c

+/* dirwrap.c */
+
+/* Directory-related system-call wrappers */
+
+/* $Id$ */
+
+/****************************************************************************
+ * @format.tab-size 4		(Plain Text/Source Code File Header)			*
+ * @format.use-tabs true	(see http://www.synchro.net/ptsc_hdr.html)		*
+ *																			*
+ * Copyright 2000 Rob Swindell - http://www.synchro.net/copyright.html		*
+ *																			*
+ * This program is free software; you can redistribute it and/or			*
+ * modify it under the terms of the GNU General Public License				*
+ * as published by the Free Software Foundation; either version 2			*
+ * of the License, or (at your option) any later version.					*
+ * See the GNU General Public License for more details: gpl.txt or			*
+ * http://www.fsf.org/copyleft/gpl.html										*
+ *																			*
+ * Anonymous FTP access to the most recent released source is available at	*
+ * ftp://vert.synchro.net, ftp://cvs.synchro.net and ftp://ftp.synchro.net	*
+ *																			*
+ * Anonymous CVS access to the development source and modification history	*
+ * is available at cvs.synchro.net:/cvsroot/sbbs, example:					*
+ * cvs -d :pserver:anonymous@cvs.synchro.net:/cvsroot/sbbs login			*
+ *     (just hit return, no password is necessary)							*
+ * cvs -d :pserver:anonymous@cvs.synchro.net:/cvsroot/sbbs checkout src		*
+ *																			*
+ * For Synchronet coding style and modification guidelines, see				*
+ * http://www.synchro.net/source.html										*
+ *																			*
+ * You are encouraged to submit any modifications (preferably in Unix diff	*
+ * format) via e-mail to mods@synchro.net									*
+ *																			*
+ * Note: If this box doesn't appear square, then you need to fix your tabs.	*
+ ****************************************************************************/
+
+#ifdef _WIN32
+
+#include <windows.h>	/* WINAPI, etc */
+#include <io.h>			/* _findfirst */
+
+#elif defined __unix__
+
+#include <unistd.h>		/* usleep */
+#include <fcntl.h>		/* O_NOCCTY */
+#include <ctype.h>		/* toupper */
+
+#ifdef __FreeBSD__
+#include <sys/param.h>
+#include <sys/mount.h>
+#include <sys/kbio.h>
+#endif
+
+#include <sys/ioctl.h>	/* ioctl */
+
+#ifdef __GLIBC__		/* actually, BSD, but will work for now */
+#include <sys/vfs.h>    /* statfs() */
+#endif
+
+#endif
+
+#include <sys/types.h>	/* _dev_t */
+#include <sys/stat.h>	/* struct stat */
+
+#include <stdio.h>		/* sprintf */
+#include <stdlib.h>		/* rand */
+#include <errno.h>		/* ENOENT definitions */
+
+#include "dirwrap.h"	/* DLLCALL */
+
+/****************************************************************************/
+/* Return the filename portion of a full pathname							*/
+/****************************************************************************/
+char* DLLCALL getfname(char* path)
+{
+	char *fname;
+
+	fname=strrchr(path,'/');
+	if(fname==NULL) 
+		fname=strrchr(path,'\\');
+	if(fname!=NULL) 
+		fname++;
+	else 
+		fname=path;
+	return(fname);
+}
+
+#if !defined(__unix__)
+/****************************************************************************/
+/* Win32 (minimal) implementation of POSIX.2 glob() function				*/
+/* This code _may_ work on other DOS-based platforms (e.g. OS/2)			*/
+/****************************************************************************/
+static int glob_compare( const void *arg1, const void *arg2 )
+{
+   /* Compare all of both strings: */
+   return stricmp( * ( char** ) arg1, * ( char** ) arg2 );
+}
+
+#ifdef __BORLANDC__
+	#pragma argsused
+#endif
+
+int	DLLCALL	glob(const char *pattern, int flags, void* unused, glob_t* glob)
+{
+    struct	_finddata_t ff;
+	long	ff_handle;
+	size_t	found=0;
+	char	path[MAX_PATH+1];
+	char*	p;
+	char**	new_pathv;
+
+	if(!(flags&GLOB_APPEND)) {
+		glob->gl_pathc=0;
+		glob->gl_pathv=NULL;
+	}
+
+	ff_handle=_findfirst((char*)pattern,&ff);
+	while(ff_handle!=-1) {
+		if(!(flags&GLOB_ONLYDIR) || ff.attrib&_A_SUBDIR) {
+			if((new_pathv=realloc(glob->gl_pathv
+				,(glob->gl_pathc+1)*sizeof(char*)))==NULL) {
+				globfree(glob);
+				return(GLOB_NOSPACE);
+			}
+			glob->gl_pathv=new_pathv;
+
+			/* build the full pathname */
+			strcpy(path,pattern);
+			p=getfname(path);
+			*p=0;
+			strcat(path,ff.name);
+
+			if((glob->gl_pathv[glob->gl_pathc]=malloc(strlen(path)+2))==NULL) {
+				globfree(glob);
+				return(GLOB_NOSPACE);
+			}
+			strcpy(glob->gl_pathv[glob->gl_pathc],path);
+			if(flags&GLOB_MARK && ff.attrib&_A_SUBDIR)
+				strcat(glob->gl_pathv[glob->gl_pathc],"/");
+
+			glob->gl_pathc++;
+			found++;
+		}
+		if(_findnext(ff_handle, &ff)!=0) {
+			_findclose(ff_handle);
+			ff_handle=-1; 
+		} 
+	}
+
+	if(found==0)
+		return(GLOB_NOMATCH);
+
+	if(!(flags&GLOB_NOSORT)) {
+		qsort(glob->gl_pathv,found,sizeof(char*),glob_compare);
+	}
+
+	return(0);	/* success */
+}
+
+void DLLCALL globfree(glob_t* glob)
+{
+	size_t i;
+
+	if(glob==NULL)
+		return;
+
+	if(glob->gl_pathv!=NULL) {
+		for(i=0;i<glob->gl_pathc;i++)
+			if(glob->gl_pathv[i]!=NULL)
+				free(glob->gl_pathv[i]);
+
+		free(glob->gl_pathv);
+		glob->gl_pathv=NULL;
+	}
+	glob->gl_pathc=0;
+}
+
+#endif /* !defined(__unix__) */
+
+/****************************************************************************/
+/* POSIX directory operations using Microsoft _findfirst/next API.			*/
+/****************************************************************************/
+#if defined(_MSC_VER)
+DIR* opendir(const char* dirname)
+{
+	DIR*	dir;
+
+	if((dir=(DIR*)calloc(1,sizeof(DIR)))==NULL) {
+		errno=ENOMEM;
+		return(NULL);
+	}
+	sprintf(dir->filespec,"%.*s",sizeof(dir->filespec)-5,dirname);
+	if(*dir->filespec && dir->filespec[strlen(dir->filespec)-1]!='\\')
+		strcat(dir->filespec,"\\");
+	strcat(dir->filespec,"*.*");
+	dir->handle=_findfirst(dir->filespec,&dir->finddata);
+	if(dir->handle==-1) {
+		errno=ENOENT;
+		free(dir);
+		return(NULL);
+	}
+	return(dir);
+}
+struct dirent* readdir(DIR* dir)
+{
+	if(dir==NULL)
+		return(NULL);
+	if(dir->end==TRUE)
+		return(NULL);
+	if(dir->handle==-1)
+		return(NULL);
+	sprintf(dir->dirent.d_name,"%.*s",sizeof(struct dirent)-1,dir->finddata.name);
+	if(_findnext(dir->handle,&dir->finddata)!=0)
+		dir->end=TRUE;
+	return(&dir->dirent);
+}
+int closedir (DIR* dir)
+{
+	if(dir==NULL)
+		return(-1);
+	_findclose(dir->handle);
+	free(dir);
+	return(0);
+}
+void rewinddir(DIR* dir)
+{
+	if(dir==NULL)
+		return;
+	_findclose(dir->handle);
+	dir->end=FALSE;
+	dir->handle=_findfirst(dir->filespec,&dir->finddata);
+}
+#endif /* defined(_MSC_VER) */
+
+/****************************************************************************/
+/* Returns the time/date of the file in 'filename' in time_t (unix) format  */
+/****************************************************************************/
+time_t DLLCALL fdate(char *filename)
+{
+	struct stat st;
+
+	if(access(filename,0)==-1)
+		return(-1);
+
+	if(stat(filename, &st)!=0)
+		return(-1);
+
+	return(st.st_mtime);
+}
+
+/****************************************************************************/
+/* Returns the length of the file in 'filename'                             */
+/****************************************************************************/
+long DLLCALL flength(char *filename)
+{
+#ifdef __BORLANDC__	/* stat() doesn't work right */
+
+	long	handle;
+	struct _finddata_t f;
+
+	if(access(filename,0)==-1)
+		return(-1L);
+
+	if((handle=_findfirst(filename,&f))==-1)
+		return(-1);
+
+ 	_findclose(handle);
+
+	return(f.size);
+
+#else 
+
+	struct stat st;
+
+	if(access(filename,0)==-1)
+		return(-1L);
+
+	if(stat(filename, &st)!=0)
+		return(-1L);
+
+	return(st.st_size);
+
+#endif
+}
+
+/****************************************************************************/
+/* Checks the file system for the existence of one or more files.			*/
+/* Returns TRUE if it exists, FALSE if it doesn't.                          */
+/* 'filespec' may contain wildcards!										*/
+/****************************************************************************/
+BOOL DLLCALL fexist(char *filespec)
+{
+#ifdef _WIN32
+
+	long	handle;
+	struct _finddata_t f;
+
+	if(access(filespec,0)==-1 && !strchr(filespec,'*') && !strchr(filespec,'?'))
+		return(FALSE);
+
+	if((handle=_findfirst(filespec,&f))==-1)
+		return(FALSE);
+
+ 	_findclose(handle);
+
+ 	if(f.attrib&_A_SUBDIR)
+		return(FALSE);
+
+	return(TRUE);
+
+#elif defined(__unix__)	/* portion by cmartin */
+
+	glob_t g;
+    int c;
+    int l;
+
+	if(access(filespec,0)==-1 && !strchr(filespec,'*') && !strchr(filespec,'?'))
+		return(FALSE);
+
+    // start the search
+    glob(filespec, GLOB_MARK | GLOB_NOSORT, NULL, &g);
+
+    if (!g.gl_pathc) {
+	    // no results
+    	globfree(&g);
+    	return FALSE;
+    }
+
+    // make sure it's not a directory
+	c = g.gl_pathc;
+    while (c--) {
+    	l = strlen(g.gl_pathv[c]);
+    	if (l && g.gl_pathv[c][l-1] != '/') {
+        	globfree(&g);
+            return TRUE;
+        }
+    }
+        
+    globfree(&g);
+    return FALSE;
+
+#else
+
+#warning "fexist() port needs to support wildcards!"
+
+	return(FALSE);
+
+#endif
+}
+
+/****************************************************************************/
+/* Returns TRUE if the filename specified is a directory					*/
+/****************************************************************************/
+BOOL DLLCALL isdir(char *filename)
+{
+	struct stat st;
+
+	if(stat(filename, &st)!=0)
+		return(FALSE);
+
+	return((st.st_mode&S_IFDIR) ? TRUE : FALSE);
+}
+
+/****************************************************************************/
+/* Returns the attributes (mode) for specified 'filename'					*/
+/****************************************************************************/
+int DLLCALL getfattr(char* filename)
+{
+#ifdef _WIN32
+	long handle;
+	struct _finddata_t	finddata;
+
+	if((handle=_findfirst(filename,&finddata))==-1) {
+		errno=ENOENT;
+		return(-1);
+	}
+	_findclose(handle);
+	return(finddata.attrib);
+#else
+	struct stat st;
+
+	if(stat(filename, &st)!=0) {
+		errno=ENOENT;
+		return(-1L);
+	}
+
+	return(st.st_mode);
+#endif
+}
+
+/****************************************************************************/
+/* Return free disk space in bytes (up to a maximum of 4GB)					*/
+/****************************************************************************/
+#ifdef _WIN32
+	typedef BOOL(WINAPI * GetDiskFreeSpaceEx_t)
+		(LPCTSTR,PULARGE_INTEGER,PULARGE_INTEGER,PULARGE_INTEGER); 
+#endif
+
+ulong DLLCALL getfreediskspace(char* path)
+{
+#ifdef _WIN32
+	char			root[16];
+	DWORD			TotalNumberOfClusters;
+	DWORD			NumberOfFreeClusters;
+	DWORD			BytesPerSector;
+	DWORD			SectorsPerCluster;
+	ULARGE_INTEGER	avail;
+	ULARGE_INTEGER	size;
+	static HINSTANCE hK32;
+	GetDiskFreeSpaceEx_t GetDiskFreeSpaceEx;
+
+	if(hK32 == NULL)
+		hK32 = LoadLibrary("KERNEL32");
+	GetDiskFreeSpaceEx 
+		= (GetDiskFreeSpaceEx_t)GetProcAddress(hK32,"GetDiskFreeSpaceExA");
+ 
+	if (GetDiskFreeSpaceEx!=NULL) {	/* Windows 95-OSR2 or later */
+		if(!GetDiskFreeSpaceEx(
+			path,		// pointer to the directory name
+			&avail,		// receives the number of bytes on disk avail to the caller
+			&size,		// receives the number of bytes on disk
+			NULL))		// receives the free bytes on disk
+			return(0);
+#ifdef _ANONYMOUS_STRUCT
+		if(avail.HighPart)
+#else
+		if(avail.u.HighPart)
+#endif
+			return(0xffffffff);	/* 4GB max */
+
+#ifdef _ANONYMOUS_STRUCT
+		return(avail.LowPart);
+#else
+		return(avail.u.LowPart);
+#endif
+	}
+
+	/* Windows 95 (old way), limited to 2GB */
+	sprintf(root,"%.3s",path);
+	if(!GetDiskFreeSpace(
+		root,					// pointer to root path
+		&SectorsPerCluster,		// pointer to sectors per cluster
+		&BytesPerSector,		// pointer to bytes per sector
+		&NumberOfFreeClusters,	// pointer to number of free clusters
+		&TotalNumberOfClusters  // pointer to total number of clusters
+		))
+		return(0);
+
+	return(NumberOfFreeClusters*SectorsPerCluster*BytesPerSector);
+
+
+/* statfs is also used under FreeBSD */
+#elif defined(__GLIBC__) || defined(__FreeBSD__)
+
+	struct statfs fs;
+