Quake-2

sys_irix.c (7346B)

---

 #include <unistd.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <limits.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <sys/ipc.h>
 #include <sys/shm.h>
 #include <sys/stat.h>
 #include <string.h>
 #include <ctype.h>
 #include <sys/wait.h>
 #include <sys/mman.h>
 #include <errno.h>
 #include <mntent.h>
 
 #include <dlfcn.h>
 
 #include "../qcommon/qcommon.h"
 
 #include "../linux/rw_linux.h"
 
 cvar_t *nostdout;
 
 unsigned	sys_frame_time;
 
 uid_t saved_euid;
 qboolean stdin_active = true;
 
 // =======================================================================
 // General routines
 // =======================================================================
 
 void Sys_ConsoleOutput (char *string)
 {
 	if (nostdout && nostdout->value)
 		return;
 
 	fputs(string, stdout);
 }
 
 void Sys_Printf (char *fmt, ...)
 {
 	va_list		argptr;
 	char		text[1024];
 	unsigned char		*p;
 
 	va_start (argptr,fmt);
 	vsprintf (text,fmt,argptr);
 	va_end (argptr);
 
 	if (strlen(text) > sizeof(text))
 		Sys_Error("memory overwrite in Sys_Printf");
 
     if (nostdout && nostdout->value)
         return;
 
 	for (p = (unsigned char *)text; *p; p++) {
 		*p &= 0x7f;
 		if ((*p > 128 || *p < 32) && *p != 10 && *p != 13 && *p != 9)
 			printf("[%02x]", *p);
 		else
 			putc(*p, stdout);
 	}
 }
 
 void Sys_Quit (void)
 {
 	CL_Shutdown ();
 	Qcommon_Shutdown ();
     fcntl (0, F_SETFL, fcntl (0, F_GETFL, 0) & ~FNDELAY);
 	_exit(0);
 }
 
 void Sys_Init(void)
 {
 #if id386
 //	Sys_SetFPCW();
 #endif
 }
 
 void Sys_Error (char *error, ...)
 { 
     va_list     argptr;
     char        string[1024];
 
 // change stdin to non blocking
     fcntl (0, F_SETFL, fcntl (0, F_GETFL, 0) & ~FNDELAY);
     
     va_start (argptr,error);
     vsprintf (string,error,argptr);
     va_end (argptr);
 	fprintf(stderr, "Error: %s\n", string);
 
 	CL_Shutdown ();
 	Qcommon_Shutdown ();
 	_exit (1);
 
 } 
 
 void Sys_Warn (char *warning, ...)
 { 
     va_list     argptr;
     char        string[1024];
     
     va_start (argptr,warning);
     vsprintf (string,warning,argptr);
     va_end (argptr);
 	fprintf(stderr, "Warning: %s", string);
 } 
 
 /*
 ============
 Sys_FileTime
 
 returns -1 if not present
 ============
 */
 int	Sys_FileTime (char *path)
 {
 	struct	stat	buf;
 	
 	if (stat (path,&buf) == -1)
 		return -1;
 	
 	return buf.st_mtime;
 }
 
 void floating_point_exception_handler(int whatever)
 {
 //	Sys_Warn("floating point exception\n");
 	signal(SIGFPE, floating_point_exception_handler);
 }
 
 char *Sys_ConsoleInput(void)
 {
     static char text[256];
     int     len;
 	fd_set	fdset;
     struct timeval timeout;
 
 	if (!dedicated || !dedicated->value)
 		return NULL;
 
 	if (!stdin_active)
 		return NULL;
 
 	FD_ZERO(&fdset);
 	FD_SET(0, &fdset); // stdin
 	timeout.tv_sec = 0;
 	timeout.tv_usec = 0;
 	if (select (1, &fdset, NULL, NULL, &timeout) == -1 || !FD_ISSET(0, &fdset))
 		return NULL;
 
 	len = read (0, text, sizeof(text));
 	if (len == 0) { // eof!
 		stdin_active = false;
 		return NULL;
 	}
 
 	if (len < 1)
 		return NULL;
 	text[len-1] = 0;    // rip off the /n and terminate
 
 	return text;
 }
 
 /*****************************************************************************/
 
 static void *game_library;
 
 /*
 =================
 Sys_UnloadGame
 =================
 */
 void Sys_UnloadGame (void)
 {
 	if (game_library) 
 		dlclose (game_library);
 	game_library = NULL;
 }
 
 /*
 =================
 Sys_GetGameAPI
 
 Loads the game dll
 =================
 */
 void *Sys_GetGameAPI (void *parms)
 {
 #ifndef REF_HARD_LINKED
 	void	*(*GetGameAPI) (void *);
 
 	char	name[MAX_OSPATH];
 	char	curpath[MAX_OSPATH];
 	char	*path;
 #ifdef __sgi
 	const char *gamename = "gamemips.so";
 #else
 #error Unknown arch
 #endif
 
 	setreuid(getuid(), getuid());
 	setegid(getgid());
 
 	if (game_library)
 		Com_Error (ERR_FATAL, "Sys_GetGameAPI without Sys_UnloadingGame");
 
 	getcwd(curpath, sizeof(curpath));
 
 	Com_Printf("------- Loading %s -------", gamename);
 
 	// now run through the search paths
 	path = NULL;
 	while (1)
 	{
 		path = FS_NextPath (path);
 		if (!path)
 			return NULL;		// couldn't find one anywhere
 		sprintf (name, "%s/%s/%s", curpath, path, gamename);
 		Com_Printf ("Trying to load library (%s)\n",name);
 		game_library = dlopen (name, RTLD_NOW );
 		if (game_library)
 		{
 			Com_DPrintf ("LoadLibrary (%s)\n",name);
 			break;
 		}
 	}
 
 	GetGameAPI = (void *)dlsym (game_library, "GetGameAPI");
 	if (!GetGameAPI)
 	{
 		Sys_UnloadGame ();		
 		return NULL;
 	}
 
 	return GetGameAPI (parms);
 #else
 	return (void *)GetGameAPI (parms);
 #endif
 }
 
 /*****************************************************************************/
 
 void Sys_AppActivate (void)
 {
 }
 
 void Sys_SendKeyEvents (void)
 {
 	if (KBD_Update_fp)
 		KBD_Update_fp();
 
 	// grab frame time 
 	sys_frame_time = Sys_Milliseconds();
 }
 
 /*****************************************************************************/
 
 char *Sys_GetClipboardData(void)
 {
 	return NULL;
 }
 
 int main (int argc, char **argv)
 {
 	int 	time, oldtime, newtime;
 
 	// go back to real user for config loads
 	saved_euid = geteuid();
 	seteuid(getuid());
 
 	Qcommon_Init(argc, argv);
 
 /* 	fcntl(0, F_SETFL, fcntl (0, F_GETFL, 0) | FNDELAY); */
 
 	nostdout = Cvar_Get("nostdout", "0", 0);
 	if (!nostdout->value) {
 /* 		fcntl(0, F_SETFL, fcntl (0, F_GETFL, 0) | FNDELAY); */
 //		printf ("Linux Quake -- Version %0.3f\n", LINUX_VERSION);
 	}
 
     oldtime = Sys_Milliseconds ();
     while (1)
     {
 // find time spent rendering last frame
 		do {
 			newtime = Sys_Milliseconds ();
 			time = newtime - oldtime;
 		} while (time < 1);
 		Qcommon_Frame (time);
 		oldtime = newtime;
     }
 
 }
 
 void Sys_CopyProtect(void)
 {
 	FILE *mnt;
 	struct mntent *ent;
 	char path[MAX_OSPATH];
 	struct stat st;
 	qboolean found_cd = false;
 
 	static qboolean checked = false;
 
 	if (checked)
 		return;
 
         Com_Printf("XXX - Sys_CopyProtect disabled\n");
 	checked = true;
 	return;
 
 	if ((mnt = setmntent("/etc/mtab", "r")) == NULL)
 		Com_Error(ERR_FATAL, "Can't read mount table to determine mounted cd location.");
 
 	while ((ent = getmntent(mnt)) != NULL) {
 		if (strcmp(ent->mnt_type, "iso9660") == 0) {
 			// found a cd file system
 			found_cd = true;
 			sprintf(path, "%s/%s", ent->mnt_dir, "install/data/quake2.exe");
 			if (stat(path, &st) == 0) {
 				// found it
 				checked = true;
 				endmntent(mnt);
 				return;
 			}
 			sprintf(path, "%s/%s", ent->mnt_dir, "Install/Data/quake2.exe");
 			if (stat(path, &st) == 0) {
 				// found it
 				checked = true;
 				endmntent(mnt);
 				return;
 			}
 			sprintf(path, "%s/%s", ent->mnt_dir, "quake2.exe");
 			if (stat(path, &st) == 0) {
 				// found it
 				checked = true;
 				endmntent(mnt);
 				return;
 			}
 		}
 	}
 	endmntent(mnt);
 
 	if (found_cd)
 		Com_Error (ERR_FATAL, "Could not find a Quake2 CD in your CD drive.");
 	Com_Error (ERR_FATAL, "Unable to find a mounted iso9660 file system.\n"
 		"You must mount the Quake2 CD in a cdrom drive in order to play.");
 }
 
 #if 0
 /*
 ================
 Sys_MakeCodeWriteable
 ================
 */
 void Sys_MakeCodeWriteable (unsigned long startaddr, unsigned long length)
 {
 
 	int r;
 	unsigned long addr;
 	int psize = getpagesize();
 
 	addr = (startaddr & ~(psize-1)) - psize;
 
 //	fprintf(stderr, "writable code %lx(%lx)-%lx, length=%lx\n", startaddr,
 //			addr, startaddr+length, length);
 
 	r = mprotect((char*)addr, length + startaddr - addr + psize, 7);
 
 	if (r < 0)
     		Sys_Error("Protection change failed\n");
 
 }
 
 #endif