Quake-III-Arena

unix_main.c (28793B)

---

 /*
 ===========================================================================
 Copyright (C) 1999-2005 Id Software, Inc.
 
 This file is part of Quake III Arena source code.
 
 Quake III Arena source code 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.
 
 Quake III Arena source code 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 General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with Foobar; if not, write to the Free Software
 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 ===========================================================================
 */
 #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>
 #ifdef __linux__ // rb010123
   #include <mntent.h>
 #endif
 #include <dlfcn.h>
 
 #ifdef __linux__
   #include <fpu_control.h> // bk001213 - force dumps on divide by zero
 #endif
 
 // FIXME TTimo should we gard this? most *nix system should comply?
 #include <termios.h>
 
 #include "../game/q_shared.h"
 #include "../qcommon/qcommon.h"
 #include "../renderer/tr_public.h"
 
 #include "linux_local.h" // bk001204
 
 // Structure containing functions exported from refresh DLL
 refexport_t re;
 
 unsigned  sys_frame_time;
 
 uid_t saved_euid;
 qboolean stdin_active = qtrue;
 
 // =============================================================
 // tty console variables
 // =============================================================
 
 // enable/disabled tty input mode
 // NOTE TTimo this is used during startup, cannot be changed during run
 static cvar_t *ttycon = NULL;
 // general flag to tell about tty console mode
 static qboolean ttycon_on = qfalse;
 // when printing general stuff to stdout stderr (Sys_Printf)
 //   we need to disable the tty console stuff
 // this increments so we can recursively disable
 static int ttycon_hide = 0;
 // some key codes that the terminal may be using
 // TTimo NOTE: I'm not sure how relevant this is
 static int tty_erase;
 static int tty_eof;
 
 static struct termios tty_tc;
 
 static field_t tty_con;
 
 // history
 // NOTE TTimo this is a bit duplicate of the graphical console history
 //   but it's safer and faster to write our own here
 #define TTY_HISTORY 32
 static field_t ttyEditLines[TTY_HISTORY];
 static int hist_current = -1, hist_count = 0;
 
 // =======================================================================
 // General routines
 // =======================================================================
 
 // bk001207 
 #define MEM_THRESHOLD 96*1024*1024
 
 /*
 ==================
 Sys_LowPhysicalMemory()
 ==================
 */
 qboolean Sys_LowPhysicalMemory() {
   //MEMORYSTATUS stat;
   //GlobalMemoryStatus (&stat);
   //return (stat.dwTotalPhys <= MEM_THRESHOLD) ? qtrue : qfalse;
   return qfalse; // bk001207 - FIXME
 }
 
 /*
 ==================
 Sys_FunctionCmp
 ==================
 */
 int Sys_FunctionCmp(void *f1, void *f2) {
   return qtrue;
 }
 
 /*
 ==================
 Sys_FunctionCheckSum
 ==================
 */
 int Sys_FunctionCheckSum(void *f1) {
   return 0;
 }
 
 /*
 ==================
 Sys_MonkeyShouldBeSpanked
 ==================
 */
 int Sys_MonkeyShouldBeSpanked( void ) {
   return 0;
 }
 
 void Sys_BeginProfiling( void ) {
 }
 
 /*
 =================
 Sys_In_Restart_f
 
 Restart the input subsystem
 =================
 */
 void Sys_In_Restart_f( void ) 
 {
   IN_Shutdown();
   IN_Init();
 }
 
 // =============================================================
 // tty console routines
 // NOTE: if the user is editing a line when something gets printed to the early console then it won't look good
 //   so we provide tty_Clear and tty_Show to be called before and after a stdout or stderr output
 // =============================================================
 
 // flush stdin, I suspect some terminals are sending a LOT of shit
 // FIXME TTimo relevant?
 void tty_FlushIn()
 {
   char key;
   while (read(0, &key, 1)!=-1);
 }
 
 // do a backspace
 // TTimo NOTE: it seems on some terminals just sending '\b' is not enough
 //   so for now, in any case we send "\b \b" .. yeah well ..
 //   (there may be a way to find out if '\b' alone would work though)
 void tty_Back()
 {
   char key;
   key = '\b';
   write(1, &key, 1);
   key = ' ';
   write(1, &key, 1);
   key = '\b';
   write(1, &key, 1);
 }
 
 // clear the display of the line currently edited
 // bring cursor back to beginning of line
 void tty_Hide()
 {
   int i;
   assert(ttycon_on);
   if (ttycon_hide)
   {
     ttycon_hide++;
     return;
   }
   if (tty_con.cursor>0)
   {
     for (i=0; i<tty_con.cursor; i++)
     {
       tty_Back();
     }
   }
   ttycon_hide++;
 }
 
 // show the current line
 // FIXME TTimo need to position the cursor if needed??
 void tty_Show()
 {
   int i;
   assert(ttycon_on);
   assert(ttycon_hide>0);
   ttycon_hide--;
   if (ttycon_hide == 0)
   {
     if (tty_con.cursor)
     {
       for (i=0; i<tty_con.cursor; i++)
       {
         write(1, tty_con.buffer+i, 1);
       }
     }
   }
 }
 
 // never exit without calling this, or your terminal will be left in a pretty bad state
 void Sys_ConsoleInputShutdown()
 {
   if (ttycon_on)
   {
     Com_Printf("Shutdown tty console\n");
     tcsetattr (0, TCSADRAIN, &tty_tc);
   }
 }
 
 void Hist_Add(field_t *field)
 {
   int i;
   assert(hist_count <= TTY_HISTORY);
   assert(hist_count >= 0);
   assert(hist_current >= -1);
   assert(hist_current <= hist_count);
   // make some room
   for (i=TTY_HISTORY-1; i>0; i--)
   {
     ttyEditLines[i] = ttyEditLines[i-1];
   }
   ttyEditLines[0] = *field;
   if (hist_count<TTY_HISTORY)
   {
     hist_count++;
   }
   hist_current = -1; // re-init
 }
 
 field_t *Hist_Prev()
 {
   int hist_prev;
   assert(hist_count <= TTY_HISTORY);
   assert(hist_count >= 0);
   assert(hist_current >= -1);
   assert(hist_current <= hist_count);
   hist_prev = hist_current + 1;
   if (hist_prev >= hist_count)
   {
     return NULL;
   }
   hist_current++;
   return &(ttyEditLines[hist_current]);
 }
 
 field_t *Hist_Next()
 {
   assert(hist_count <= TTY_HISTORY);
   assert(hist_count >= 0);
   assert(hist_current >= -1);
   assert(hist_current <= hist_count);
   if (hist_current >= 0)
   {
     hist_current--;
   }
   if (hist_current == -1)
   {
     return NULL;
   }
   return &(ttyEditLines[hist_current]);
 }
 
 // =============================================================
 // general sys routines
 // =============================================================
 
 #if 0
 // NOTE TTimo this is not used .. looks interesting though? protection against buffer overflow kind of stuff?
 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");
 
   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);
   }
 }
 #endif
 
 // single exit point (regular exit or in case of signal fault)
 void Sys_Exit( int ex ) {
   Sys_ConsoleInputShutdown();
 
 #ifdef NDEBUG // regular behavior
 
   // We can't do this 
   //  as long as GL DLL's keep installing with atexit...
   //exit(ex);
   _exit(ex);
 #else
 
   // Give me a backtrace on error exits.
   assert( ex == 0 );
   exit(ex);
 #endif
 }
 
 
 void Sys_Quit (void) {
   CL_Shutdown ();
   fcntl (0, F_SETFL, fcntl (0, F_GETFL, 0) & ~FNDELAY);
   Sys_Exit(0);
 }
 
 void Sys_Init(void)
 {
   Cmd_AddCommand ("in_restart", Sys_In_Restart_f);
 
 #if defined __linux__
 #if defined __i386__
   Cvar_Set( "arch", "linux i386" );
 #elif defined __alpha__
   Cvar_Set( "arch", "linux alpha" );
 #elif defined __sparc__
   Cvar_Set( "arch", "linux sparc" );
 #elif defined __FreeBSD__
 
 #if defined __i386__ // FreeBSD
   Cvar_Set( "arch", "freebsd i386" );
 #elif defined __alpha__
   Cvar_Set( "arch", "freebsd alpha" );
 #else
   Cvar_Set( "arch", "freebsd unknown" );
 #endif // FreeBSD
 
 #else
   Cvar_Set( "arch", "linux unknown" );
 #endif
 #elif defined __sun__
 #if defined __i386__
   Cvar_Set( "arch", "solaris x86" );
 #elif defined __sparc__
   Cvar_Set( "arch", "solaris sparc" );
 #else
   Cvar_Set( "arch", "solaris unknown" );
 #endif
 #elif defined __sgi__
 #if defined __mips__
   Cvar_Set( "arch", "sgi mips" );
 #else
   Cvar_Set( "arch", "sgi unknown" );
 #endif
 #else
   Cvar_Set( "arch", "unknown" );
 #endif
 
   Cvar_Set( "username", Sys_GetCurrentUser() );
 
   IN_Init();
 
 }
 
 void  Sys_Error( const char *error, ...)
 { 
   va_list     argptr;
   char        string[1024];
 
   // change stdin to non blocking
   // NOTE TTimo not sure how well that goes with tty console mode
   fcntl (0, F_SETFL, fcntl (0, F_GETFL, 0) & ~FNDELAY);
 
   // don't bother do a show on this one heh
   if (ttycon_on)
   {
     tty_Hide();
   }
 
   CL_Shutdown ();
 
   va_start (argptr,error);
   vsprintf (string,error,argptr);
   va_end (argptr);
   fprintf(stderr, "Sys_Error: %s\n", string);
 
   Sys_Exit( 1 ); // bk010104 - use single exit point.
 } 
 
 void Sys_Warn (char *warning, ...)
 { 
   va_list     argptr;
   char        string[1024];
 
   va_start (argptr,warning);
   vsprintf (string,warning,argptr);
   va_end (argptr);
 
   if (ttycon_on)
   {
     tty_Hide();
   }
 
   fprintf(stderr, "Warning: %s", string);
 
   if (ttycon_on)
   {
     tty_Show();
   }
 } 
 
 /*
 ============
 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)
 {
   signal(SIGFPE, floating_point_exception_handler);
 }
 
 // initialize the console input (tty mode if wanted and possible)
 void Sys_ConsoleInputInit()
 {
   struct termios tc;
 
   // TTimo 
   // https://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=390
   // ttycon 0 or 1, if the process is backgrounded (running non interactively)
   // then SIGTTIN or SIGTOU is emitted, if not catched, turns into a SIGSTP
   signal(SIGTTIN, SIG_IGN);
   signal(SIGTTOU, SIG_IGN);
 
   // FIXME TTimo initialize this in Sys_Init or something?
   ttycon = Cvar_Get("ttycon", "1", 0);
   if (ttycon && ttycon->value)
   {
     if (isatty(STDIN_FILENO)!=1)
     {
       Com_Printf("stdin is not a tty, tty console mode failed\n");
       Cvar_Set("ttycon", "0");
       ttycon_on = qfalse;
       return;
     }
     Com_Printf("Started tty console (use +set ttycon 0 to disable)\n");
     Field_Clear(&tty_con);
     tcgetattr (0, &tty_tc);
     tty_erase = tty_tc.c_cc[VERASE];
     tty_eof = tty_tc.c_cc[VEOF];
     tc = tty_tc;
     /*
      ECHO: don't echo input characters
      ICANON: enable canonical mode.  This  enables  the  special
               characters  EOF,  EOL,  EOL2, ERASE, KILL, REPRINT,
               STATUS, and WERASE, and buffers by lines.
      ISIG: when any of the characters  INTR,  QUIT,  SUSP,  or
               DSUSP are received, generate the corresponding sig­
               nal
     */              
     tc.c_lflag &= ~(ECHO | ICANON);
     /*
      ISTRIP strip off bit 8
      INPCK enable input parity checking
      */
     tc.c_iflag &= ~(ISTRIP | INPCK);
     tc.c_cc[VMIN] = 1;
     tc.c_cc[VTIME] = 0;
     tcsetattr (0, TCSADRAIN, &tc);    
     ttycon_on = qtrue;
   } else
     ttycon_on = qfalse;
 }
 
 char *Sys_ConsoleInput(void)
 {
   // we use this when sending back commands
   static char text[256];
   int i;
   int avail;
   char key;
   field_t *history;
 
   if (ttycon && ttycon->value)
   {
     avail = read(0, &key, 1);
     if (avail != -1)
     {
       // we have something
       // backspace?
       // NOTE TTimo testing a lot of values .. seems it's the only way to get it to work everywhere
       if ((key == tty_erase) || (key == 127) || (key == 8))
       {
         if (tty_con.cursor > 0)
         {
           tty_con.cursor--;
           tty_con.buffer[tty_con.cursor] = '\0';
           tty_Back();
         }
         return NULL;
       }
       // check if this is a control char
       if ((key) && (key) < ' ')
       {
         if (key == '\n')
         {
           // push it in history
           Hist_Add(&tty_con);
           strcpy(text, tty_con.buffer);
           Field_Clear(&tty_con);
           key = '\n';
           write(1, &key, 1);
           return text;
         }
         if (key == '\t')
         {
           tty_Hide();
           Field_CompleteCommand( &tty_con );
           // Field_CompleteCommand does weird things to the string, do a cleanup
           //   it adds a '\' at the beginning of the string
           //   cursor doesn't reflect actual length of the string that's sent back
           tty_con.cursor = strlen(tty_con.buffer);
           if (tty_con.cursor>0)
           {
             if (tty_con.buffer[0] == '\\')
             {
               for (i=0; i<=tty_con.cursor; i++)
               {
                 tty_con.buffer[i] = tty_con.buffer[i+1];
               }
               tty_con.cursor--;
             }
           }
           tty_Show();
           return NULL;
         }
         avail = read(0, &key, 1);
         if (avail != -1)
         {
           // VT 100 keys
           if (key == '[' || key == 'O')
           {
             avail = read(0, &key, 1);
             if (avail != -1)
             {
               switch (key)
               {
               case 'A':
                 history = Hist_Prev();
                 if (history)
                 {
                   tty_Hide();
                   tty_con = *history;
                   tty_Show();
                 }
                 tty_FlushIn();
                 return NULL;
                 break;
               case 'B':
                 history = Hist_Next();
                 tty_Hide();
                 if (history)
                 {
                   tty_con = *history;
                 } else
                 {
                   Field_Clear(&tty_con);
                 }
                 tty_Show();
                 tty_FlushIn();
                 return NULL;
                 break;
               case 'C':
                 return NULL;
               case 'D':
                 return NULL;
               }
             }
           }
         }
         Com_DPrintf("droping ISCTL sequence: %d, tty_erase: %d\n", key, tty_erase);
         tty_FlushIn();
         return NULL;
       }
       // push regular character
       tty_con.buffer[tty_con.cursor] = key;
       tty_con.cursor++;
       // print the current line (this is differential)
       write(1, &key, 1);
     }
     return NULL;
   } else
   {
     int     len;
     fd_set  fdset;
     struct timeval timeout;
 
     if (!com_dedicated || !com_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 = qfalse;
       return NULL;
     }
 
     if (len < 1)
       return NULL;
     text[len-1] = 0;    // rip off the /n and terminate
 
     return text;
   }
 }
 
 /*****************************************************************************/
 
 /*
 =================
 Sys_UnloadDll
 
 =================
 */
 void Sys_UnloadDll( void *dllHandle ) {
   // bk001206 - verbose error reporting
   const char* err; // rb010123 - now const
   if ( !dllHandle )
   {
     Com_Printf("Sys_UnloadDll(NULL)\n");
     return;
   }
   dlclose( dllHandle );
   err = dlerror();
   if ( err != NULL )
     Com_Printf ( "Sys_UnloadGame failed on dlclose: \"%s\"!\n", err );
 }
 
 
 /*
 =================
 Sys_LoadDll
 
 Used to load a development dll instead of a virtual machine
 TTimo:
 changed the load procedure to match VFS logic, and allow developer use
 #1 look down current path
 #2 look in fs_homepath
 #3 look in fs_basepath
 =================
 */
 extern char   *FS_BuildOSPath( const char *base, const char *game, const char *qpath );
 
 void *Sys_LoadDll( const char *name, char *fqpath ,
                    int (**entryPoint)(int, ...),
                    int (*systemcalls)(int, ...) ) 
 {
   void *libHandle;
   void  (*dllEntry)( int (*syscallptr)(int, ...) );
   char  curpath[MAX_OSPATH];
   char  fname[MAX_OSPATH];
   char  *basepath;
   char  *homepath;
   char  *pwdpath;
   char  *gamedir;
   char  *fn;
   const char*  err = NULL;
 	
 	*fqpath = 0;
 
   // bk001206 - let's have some paranoia
   assert( name );
 
   getcwd(curpath, sizeof(curpath));
 #if defined __i386__
   snprintf (fname, sizeof(fname), "%si386.so", name);
 #elif defined __powerpc__   //rcg010207 - PPC support.
   snprintf (fname, sizeof(fname), "%sppc.so", name);
 #elif defined __axp__
   snprintf (fname, sizeof(fname), "%saxp.so", name);
 #elif defined __mips__
   snprintf (fname, sizeof(fname), "%smips.so", name);
 #else
 #error Unknown arch
 #endif
 
 // bk001129 - was RTLD_LAZY 
 #define Q_RTLD    RTLD_NOW
 
   pwdpath = Sys_Cwd();
   basepath = Cvar_VariableString( "fs_basepath" );
   homepath = Cvar_VariableString( "fs_homepath" );
   gamedir = Cvar_VariableString( "fs_game" );
 
   // pwdpath
   fn = FS_BuildOSPath( pwdpath, gamedir, fname );
   Com_Printf( "Sys_LoadDll(%s)... \n", fn );
   libHandle = dlopen( fn, Q_RTLD );
 
   if ( !libHandle )
   {
     Com_Printf( "Sys_LoadDll(%s) failed:\n\"%s\"\n", fn, dlerror() );
     // fs_homepath
     fn = FS_BuildOSPath( homepath, gamedir, fname );
     Com_Printf( "Sys_LoadDll(%s)... \n", fn );
     libHandle = dlopen( fn, Q_RTLD );
 
     if ( !libHandle )
     {
       Com_Printf( "Sys_LoadDll(%s) failed:\n\"%s\"\n", fn, dlerror() );
       // fs_basepath
       fn = FS_BuildOSPath( basepath, gamedir, fname );
       Com_Printf( "Sys_LoadDll(%s)... \n", fn );
       libHandle = dlopen( fn, Q_RTLD );
 
       if ( !libHandle )
       {
 #ifndef NDEBUG // bk001206 - in debug abort on failure
         Com_Error ( ERR_FATAL, "Sys_LoadDll(%s) failed dlopen() completely!\n", name  );
 #else
         Com_Printf ( "Sys_LoadDll(%s) failed dlopen() completely!\n", name );
 #endif
         return NULL;
       } else
         Com_Printf ( "Sys_LoadDll(%s): succeeded ...\n", fn );
     } else
       Com_Printf ( "Sys_LoadDll(%s): succeeded ...\n", fn );
   } else
     Com_Printf ( "Sys_LoadDll(%s): succeeded ...\n", fn ); 
 
   dllEntry = dlsym( libHandle, "dllEntry" ); 
   *entryPoint = dlsym( libHandle, "vmMain" );
   if ( !*entryPoint || !dllEntry )
   {
     err = dlerror();
 #ifndef NDEBUG // bk001206 - in debug abort on failure
     Com_Error ( ERR_FATAL, "Sys_LoadDll(%s) failed dlsym(vmMain):\n\"%s\" !\n", name, err );
 #else
     Com_Printf ( "Sys_LoadDll(%s) failed dlsym(vmMain):\n\"%s\" !\n", name, err );
 #endif
     dlclose( libHandle );
     err = dlerror();
     if ( err != NULL )
       Com_Printf ( "Sys_LoadDll(%s) failed dlcose:\n\"%s\"\n", name, err );
     return NULL;
   }
   Com_Printf ( "Sys_LoadDll(%s) found **vmMain** at  %p  \n", name, *entryPoint ); // bk001212
   dllEntry( systemcalls );
   Com_Printf ( "Sys_LoadDll(%s) succeeded!\n", name );
   if ( libHandle ) Q_strncpyz ( fqpath , fn , MAX_QPATH ) ;		// added 7/20/02 by T.Ray
   return libHandle;
 }
 
 /*
 ========================================================================
 
 BACKGROUND FILE STREAMING
 
 ========================================================================
 */
 
 #if 1
 
 void Sys_InitStreamThread( void ) {
 }
 
 void Sys_ShutdownStreamThread( void ) {
 }
 
 void Sys_BeginStreamedFile( fileHandle_t f, int readAhead ) {
 }
 
 void Sys_EndStreamedFile( fileHandle_t f ) {
 }
 
 int Sys_StreamedRead( void *buffer, int size, int count, fileHandle_t f ) {
   return FS_Read( buffer, size * count, f );
 }
 
 void Sys_StreamSeek( fileHandle_t f, int offset, int origin ) {
   FS_Seek( f, offset, origin );
 }
 
 #else
 
 typedef struct
 {
   fileHandle_t file;
   byte  *buffer;
   qboolean  eof;
   int   bufferSize;
   int   streamPosition; // next byte to be returned by Sys_StreamRead
   int   threadPosition; // next byte to be read from file
 } streamState_t;
 
 streamState_t stream;
 
 /*
 ===============
 Sys_StreamThread
 
 A thread will be sitting in this loop forever
 ================
 */
 void Sys_StreamThread( void ) 
 {
   int   buffer;
   int   count;
   int   readCount;
   int   bufferPoint;
   int   r;
 
   // if there is any space left in the buffer, fill it up
   if ( !stream.eof )
   {
     count = stream.bufferSize - (stream.threadPosition - stream.streamPosition);
     if ( count )
     {
       bufferPoint = stream.threadPosition % stream.bufferSize;
       buffer = stream.bufferSize - bufferPoint;
       readCount = buffer < count ? buffer : count;
       r = FS_Read ( stream.buffer + bufferPoint, readCount, stream.file );
       stream.threadPosition += r;
 
       if ( r != readCount )
         stream.eof = qtrue;
     }
   }
 }
 
 /*
 ===============
 Sys_InitStreamThread
 
 ================
 */
 void Sys_InitStreamThread( void ) 
 {
 }
 
 /*
 ===============
 Sys_ShutdownStreamThread
 
 ================
 */
 void Sys_ShutdownStreamThread( void ) 
 {
 }
 
 
 /*
 ===============
 Sys_BeginStreamedFile
 
 ================
 */
 void Sys_BeginStreamedFile( fileHandle_t f, int readAhead ) 
 {
   if ( stream.file )
   {
     Com_Error( ERR_FATAL, "Sys_BeginStreamedFile: unclosed stream");
   }
 
   stream.file = f;
   stream.buffer = Z_Malloc( readAhead );
   stream.bufferSize = readAhead;
   stream.streamPosition = 0;
   stream.threadPosition = 0;
   stream.eof = qfalse;
 }
 
 /*
 ===============
 Sys_EndStreamedFile
 
 ================
 */
 void Sys_EndStreamedFile( fileHandle_t f ) 
 {
   if ( f != stream.file )
   {
     Com_Error( ERR_FATAL, "Sys_EndStreamedFile: wrong file");
   }
 
   stream.file = 0;
   Z_Free( stream.buffer );
 }
 
 
 /*
 ===============
 Sys_StreamedRead
 
 ================
 */
 int Sys_StreamedRead( void *buffer, int size, int count, fileHandle_t f ) 
 {
   int   available;
   int   remaining;
   int   sleepCount;
   int   copy;
   int   bufferCount;
   int   bufferPoint;
   byte  *dest;
 
   dest = (byte *)buffer;
   remaining = size * count;
 
   if ( remaining <= 0 )
   {
     Com_Error( ERR_FATAL, "Streamed read with non-positive size" );
   }
 
   sleepCount = 0;
   while ( remaining > 0 )
   {
     available = stream.threadPosition - stream.streamPosition;
     if ( !available )
     {
       if (stream.eof)
         break;
       Sys_StreamThread();
       continue;
     }
 
     bufferPoint = stream.streamPosition % stream.bufferSize;
     bufferCount = stream.bufferSize - bufferPoint;
 
     copy = available < bufferCount ? available : bufferCount;
     if ( copy > remaining )
     {
       copy = remaining;
     }
     memcpy( dest, stream.buffer + bufferPoint, copy );
     stream.streamPosition += copy;
     dest += copy;
     remaining -= copy;
   }
 
   return(count * size - remaining) / size;
 }
 
 /*
 ===============
 Sys_StreamSeek
 
 ================
 */
 void Sys_StreamSeek( fileHandle_t f, int offset, int origin ) {
   // clear to that point
   FS_Seek( f, offset, origin );
   stream.streamPosition = 0;
   stream.threadPosition = 0;
   stream.eof = qfalse;
 }
 
 #endif
 
 /*
 ========================================================================
 
 EVENT LOOP
 
 ========================================================================
 */
 
 // bk000306: upped this from 64
 #define	MAX_QUED_EVENTS		256
 #define	MASK_QUED_EVENTS	( MAX_QUED_EVENTS - 1 )
 
 sysEvent_t  eventQue[MAX_QUED_EVENTS];
 // bk000306: initialize
 int   eventHead = 0;
 int             eventTail = 0;
 byte    sys_packetReceived[MAX_MSGLEN];
 
 /*
 ================
 Sys_QueEvent
 
 A time of 0 will get the current time
 Ptr should either be null, or point to a block of data that can
 be freed by the game later.
 ================
 */
 void Sys_QueEvent( int time, sysEventType_t type, int value, int value2, int ptrLength, void *ptr ) {
   sysEvent_t  *ev;
 
   ev = &eventQue[ eventHead & MASK_QUED_EVENTS ];
 
   // bk000305 - was missing
   if ( eventHead - eventTail >= MAX_QUED_EVENTS )
   {
     Com_Printf("Sys_QueEvent: overflow\n");
     // we are discarding an event, but don't leak memory
     if ( ev->evPtr )
     {
       Z_Free( ev->evPtr );
     }
     eventTail++;
   }
 
   eventHead++;
 
   if ( time == 0 )
   {
     time = Sys_Milliseconds();
   }
 
   ev->evTime = time;
   ev->evType = type;
   ev->evValue = value;
   ev->evValue2 = value2;
   ev->evPtrLength = ptrLength;
   ev->evPtr = ptr;
 }
 
 /*
 ================
 Sys_GetEvent
 
 ================
 */
 sysEvent_t Sys_GetEvent( void ) {
   sysEvent_t  ev;
   char    *s;
   msg_t   netmsg;
   netadr_t  adr;
 
   // return if we have data
   if ( eventHead > eventTail )
   {
     eventTail++;
     return eventQue[ ( eventTail - 1 ) & MASK_QUED_EVENTS ];
   }
 
   // pump the message loop
   // in vga this calls KBD_Update, under X, it calls GetEvent
   Sys_SendKeyEvents ();
 
   // check for console commands
   s = Sys_ConsoleInput();
   if ( s )
   {
     char  *b;
     int   len;
 
     len = strlen( s ) + 1;
     b = Z_Malloc( len );
     strcpy( b, s );
     Sys_QueEvent( 0, SE_CONSOLE, 0, 0, len, b );
   }
 
   // check for other input devices
   IN_Frame();
 
   // check for network packets
   MSG_Init( &netmsg, sys_packetReceived, sizeof( sys_packetReceived ) );
   if ( Sys_GetPacket ( &adr, &netmsg ) )
   {
     netadr_t    *buf;
     int       len;
 
     // copy out to a seperate buffer for qeueing
     len = sizeof( netadr_t ) + netmsg.cursize;
     buf = Z_Malloc( len );
     *buf = adr;
     memcpy( buf+1, netmsg.data, netmsg.cursize );
     Sys_QueEvent( 0, SE_PACKET, 0, 0, len, buf );
   }
 
   // return if we have data
   if ( eventHead > eventTail )
   {
     eventTail++;
     return eventQue[ ( eventTail - 1 ) & MASK_QUED_EVENTS ];
   }
 
   // create an empty event to return
 
   memset( &ev, 0, sizeof( ev ) );
   ev.evTime = Sys_Milliseconds();
 
   return ev;
 }
 
 /*****************************************************************************/
 
 qboolean Sys_CheckCD( void ) {
   return qtrue;
 }
 
 void Sys_AppActivate (void)
 {
 }
 
 char *Sys_GetClipboardData(void)
 {
   return NULL;
 }
 
 void  Sys_Print( const char *msg )
 {
   if (ttycon_on)
   {
     tty_Hide();
   }
   fputs(msg, stderr);
   if (ttycon_on)
   {
     tty_Show();
   }
 }
 
 
 void    Sys_ConfigureFPU() { // bk001213 - divide by zero
 #ifdef __linux__
 #ifdef __i386
 #ifndef NDEBUG
 
   // bk0101022 - enable FPE's in debug mode
   static int fpu_word = _FPU_DEFAULT & ~(_FPU_MASK_ZM | _FPU_MASK_IM);
   int current = 0;
   _FPU_GETCW(current);
   if ( current!=fpu_word)
   {
 #if 0
     Com_Printf("FPU Control 0x%x (was 0x%x)\n", fpu_word, current );
     _FPU_SETCW( fpu_word );
     _FPU_GETCW( current );
     assert(fpu_word==current);
 #endif
   }
 #else // NDEBUG
   static int fpu_word = _FPU_DEFAULT;
   _FPU_SETCW( fpu_word );
 #endif // NDEBUG
 #endif // __i386 
 #endif // __linux
 }
 
 void Sys_PrintBinVersion( const char* name ) {
   char* date = __DATE__;
   char* time = __TIME__;
   char* sep = "==============================================================";
   fprintf( stdout, "\n\n%s\n", sep );
 #ifdef DEDICATED
   fprintf( stdout, "Linux Quake3 Dedicated Server [%s %s]\n", date, time );  
 #else
   fprintf( stdout, "Linux Quake3 Full Executable  [%s %s]\n", date, time );  
 #endif
   fprintf( stdout, " local install: %s\n", name );
   fprintf( stdout, "%s\n\n", sep );
 }
 
 void Sys_ParseArgs( int argc, char* argv[] ) {
 
   if ( argc==2 )
   {
     if ( (!strcmp( argv[1], "--version" ))
          || ( !strcmp( argv[1], "-v" )) )
     {
       Sys_PrintBinVersion( argv[0] );
       Sys_Exit(0);
     }
   }
 }
 
 #include "../client/client.h"
 extern clientStatic_t cls;
 
 int main ( int argc, char* argv[] )
 {
   // int 	oldtime, newtime; // bk001204 - unused
   int   len, i;
   char  *cmdline;
   void Sys_SetDefaultCDPath(const char *path);
 
   // go back to real user for config loads
   saved_euid = geteuid();
   seteuid(getuid());
 
   Sys_ParseArgs( argc, argv );  // bk010104 - added this for support
 
   Sys_SetDefaultCDPath(argv[0]);
 
   // merge the command line, this is kinda silly
   for (len = 1, i = 1; i < argc; i++)
     len += strlen(argv[i]) + 1;
   cmdline = malloc(len);
   *cmdline = 0;
   for (i = 1; i < argc; i++)
   {
     if (i > 1)
       strcat(cmdline, " ");
     strcat(cmdline, argv[i]);
   }
 
   // bk000306 - clear queues
   memset( &eventQue[0], 0, MAX_QUED_EVENTS*sizeof(sysEvent_t) ); 
   memset( &sys_packetReceived[0], 0, MAX_MSGLEN*sizeof(byte) );
 
   Com_Init(cmdline);
   NET_Init();
 
   Sys_ConsoleInputInit();
 
   fcntl(0, F_SETFL, fcntl (0, F_GETFL, 0) | FNDELAY);
 	
 #ifdef DEDICATED
 	// init here for dedicated, as we don't have GLimp_Init
 	InitSig();
 #endif
 
   while (1)
   {
 #ifdef __linux__
     Sys_ConfigureFPU();
 #endif
     Com_Frame ();
   }
 }