home *** CD-ROM | disk | FTP | other *** search
/ rtsi.com / 2014.01.www.rtsi.com.tar / www.rtsi.com / OS9 / OSK / CMDS / SYSMON.lzh / sysmon.c
Text File  |  1993-03-09  |  167KB  |  5,515 lines
  1. /******************* S Y S M O N  -  S O U R C E ******************************
  2. *
  3. * This source code is the proprietary confidential property of
  4. * MAX PLANCK INSTITUTE KERNPHYSIK HEIDELBERG, and is provided to licensee
  5. * solely for documentation and educational purposes.  Reproduction,
  6. * publication, or distribution in any form to any party other than
  7. * the licensee is prohibited.
  8. * I have decided to distribute the source code to everybody on request !
  9. * Everybody who makes any changes to that program is pleased to send the 
  10. * latest version to the Author: F.R.Schmitt MPI/HD
  11. * So please, if you make any changes to that program, send a copy of the
  12. * source code to F.R.Schmitt [ jnet%"SCHMITT@DHDMPI5H" ] or direct
  13. * via poste to:
  14. *
  15. *                F.R.Schmitt / [TSR-GROUP/NB]
  16. *                Max-Planck Institude Nuclear Physics Heidelberg
  17. *                P.O-BOX 103980
  18. *                D-W-6900 Heidelberg
  19. *                Germany
  20. *                MAIL: jnet%"SCHMITT@DHDMPI5H"
  21. *                BTX:  *0622454879#
  22. *                PAKET-RADIO: DF3UM @ DB0GV.DL.EU    [Amateur-Radio]
  23. *                             DF3UM v DB0EQ          [Amateur-Radio direct]
  24. *                             DF3UM v DB0AAI         [Amateur-Radio direct]
  25. *                PHONE MPI: (06221)/516-284  or  516-515
  26. *                PRIVATE  : (06224)/54879     (telephone answering machine)
  27. *                
  28. *
  29. * Any change to this program is allowed as long the copyright message in
  30. * show_version() is displayed !
  31. * If You make any changes to the program let the versionnumber the same,
  32. * example: if versionnumber is 6.0 your new version can be 6.0a or 6.01 etc.
  33. *
  34. * So feel free to extend the program and to install new routines for other
  35. * terminals then VT100
  36. * Don't finally forget to send Your changed version to the author !
  37. *
  38. * NOTE: The Author is not responseable for any damage caused by this
  39. *       program !  
  40. *
  41. *!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  42. * Some advices how to compile the program:
  43. * The program should be compiled by a SUPER USER i.e. Group.Usr 0.X !
  44. * To compile the program say : "cc -it=/r0 -E=61 -BG -M=20 sysmon.c"
  45. * if you have a 68020 CPU say: "cc -it=/r0 -E=61 -BG -M=20 -K=2f sysmon.c"
  46. * if you have a 68040 CPU say: "cc -it=/r0 -E=61 -BG -X -M=20 -K=2f sysmon.c"
  47. * if you have a 68040 CPU and the Microware FPU-module say:
  48. *                              "cc -it=/r0 -E=61 -BG -M=20 -K=2f sysmon.c"
  49. *                                    ^        ^
  50. *                                    |        |
  51. *                                    | Edition-number i.e. 6.1
  52. *                                    |
  53. * NOTE: if you are using the option '-t=/r0' keep track that the size
  54. *       of your ram-disk is at least 2 MB , otherwise don't use it !!!
  55. *
  56. *
  57. *
  58. *  GOOD LUCK !
  59. *                FRANK
  60. ********************************************************************************
  61. *  PS: Special thanks to A.Kotanski [DESY/Germany] for the help of debugging
  62. *      the get_cputime() routine and to Doug Kemp [CERN/SWISS] for distributing 
  63. *      the program ! 
  64. *
  65. *      Special thanks also to F.Koeck [MPIK/HD/Germany] for debugging and 
  66. *      discussing the NETWORK-BUG [no longer hangup at network access] and
  67. *      for the ideas of some new features !!!
  68. *
  69. *      Special thanks also to H.Falb  [Schenck/Ap.EED-L/Germany] for providing
  70. *      information of the UNDOCUMENTED SYSTEMCALL  'OS9 I$SGetSt' !!!
  71. *
  72. *
  73. *
  74. *      |----------------------------------------------------|
  75. *      !  ! This program is dedicated to Ruth S. Schmitt !  !
  76. *      |----------------------------------------------------|
  77. *
  78. *
  79. *********************************************************************************
  80. * Edition History   last edition date:                                          */
  81. #define LAST_EDITION_DATE "09.03.1993"
  82. #define versi "V6.1"
  83. /*-------------------------------------------------------------------------------
  84. * ED        Date             Comments                                       by
  85. *----     ----------    ------------------------------------------------   -----  
  86. *-01        26-05-88         Start of development                           FRS
  87. *-02        14-08-88         User option implemented                        FRS
  88. *-03        06-12-88         Alphanumeric mode implemented                  FRS        
  89. *-04        23-02-89         CPU Processor type                             FRS
  90. *-05        02-03-89         Full line                                      FRS
  91. *-06        25-01-90         Switch forward & backwards (+/-)               FRS
  92. *-07        22-06-90         Kill process OPTION implemented                FRS
  93. *-08        10-07-90         Several bugs removed and more comfort impl.    FRS
  94. *-09        28-08-90         Several extentsions implemented                FRS
  95. *-10        18-09-90         Speed up the code                              FRS
  96. *-11        26-09-90         Alpha extended mode                            FRS
  97. *-12        09-10-90         Max-Hold-Function implemented                  FRS
  98. *-13        11-10-90         Big Bug in get_cputime() removed !             FRS
  99. *-14        21-11-90         Get the /dd name from the init module          FRS
  100. *-15        27-11-90         Module information option implemented          FRS
  101. *-16        12-02-91         TaskStop & RESET option implemented            FRS
  102. *-17        06-08-91         Automatic timeout for inkey routine            FRS
  103. *-18        01-10-91         RESET only for SUPERUSER via network !         FRS
  104. *-19        08-10-91         BIG BUG REMOVED FOR NETWORK ACCESS ! [fflush]  FRS
  105. *-20        25-10-91         LOGFILE OPTION IMPLEMENTED !                   FRS
  106. *-21        30-10-91         BUG IN SELECT ROUTINE REMOVED !                FRS        
  107. *-22        22-11-91         MORE USERINFORMATION PROVIDED !                FRS
  108. *-23        27-11-91         BIG BUG IN INTERCEPT HANDLING REMOVED          FRS
  109. *-24        17-12-91         CENTERING OF NODENAME IMPLEMENTED              FRS 
  110. *-25        10-01-92         CHANGED DELAY-TIME VIA TCPIP TELNET            FRS
  111. *-26        22-01-92         DISPLAY-ROUTINE CLEANUP                        FRS
  112. *-27        27-01-92         CURSOR KEYS OPTION IMPLEMENTED                 FRS
  113. *-28        10-02-92         BUG IN REFRESH ROUTINE REMOVED                 FRS
  114. *-29        12-02-92         TERMINAL CHECK IMPLEMENTED !                   FRS
  115. *-30        17-02-92         CORRECT TIMEOUT TO EXACT SECOND VALUE          FRS
  116. *-31        11-03-92         BUG IN SWITCH_CTRL FIXED !                     FRS
  117. *-32        12-03-92         FORKING THE SHELL WHICH IS SET WITH SETENV     FRS
  118. *-34        13-03-92         IOPATH-OPTION 'V' IMPLEMENTED                  FRS
  119. *-35        16-03-92         SYSTEMCALL DISPLAY IMPLEMENTED IN 'B' OPTION ! FRS
  120. *-36        18-03-92         MORE ACCURACY & SPEEDUP IN GET_CPUTIME ROUTINE FRS
  121. *-37        24-03-92         CREATION OF NODEDEF FILE IF DOESN'T EXIST      FRS
  122. *-38        27-03-92         USERSETTINGS LOAD/SAVE IMPLEMENTED !           FRS
  123. *-39        29-04-92         PROOFPASSWORD-ROUTINE MODIFIED !               FRS
  124. *-40        12-05-92         CHANGES IN 2. STATUSLINE ARE NOW HIGHLIGHTED ! FRS
  125. *-41        13-05-92         GENERAL CLEANUP PERFORMED !                    FRS
  126. *-42        28-10-92         For unpriviledged users :LOGIN instead of zsh  FRS
  127. *-43        19-02-93         Bug fixed  get_cputime [thanks to A.Kotanski]  FRS
  128. *-44        09-03-93         Nicer Outfit at helpuser-routine               FRS
  129. * 
  130. *
  131. */
  132. /*--------------------- DEFINITION OF INCLUDE FILES --------------------------*/
  133.  
  134. #include <procid.h>
  135. #include <time.h>
  136. #include <stdio.h>
  137. #include <modes.h>
  138. #include <errno.h>
  139. #include <signal.h>
  140. #include <sgstat.h>
  141. #include <ctype.h>
  142. #include <direct.h>
  143.  
  144. /*------------------------ DEFINITION OF CONSTANTS----------------------------*/
  145.  
  146. #define ESC 0x1b        
  147. #define DATAPRESENT 512        
  148. #define MAXPROCS 512        
  149. #define TRUE 1
  150. #define FALSE 0
  151. #define DONE  2
  152. #define TRISTATE 2
  153. #define TIMEOUT 3
  154. #define ON 1
  155. #define OFF 0
  156. #define SUSPEND 3
  157. #define REMOVE  4
  158. #define GET 2
  159. #define RESTORE 3
  160. #define STANDARDPRIOR 128
  161. #define MAXUSERS 100            /* maximum number of users in passwordfile */
  162. #define MAXLOGSIZE 200*1024     /* max. size of LOGFILE */
  163. #define ARG_ENV_NUM 5
  164. #define ARG_ENV_LEN 100
  165. #define PASSWORDPROOFTIME 20    /* all XX minutes proof the passwordfile ! */
  166. #ifdef DEMO
  167. #define DEMOMON 12
  168. #define DEMOYEAR 93
  169. #endif
  170. /*------------------------ DECLARATION OF GLOBAL VARIABLES -------------------*/
  171. FILE *lpp;
  172. char logfilenam[100];
  173. char logindi=FALSE;
  174. int  logfilesize=0;
  175. int  logpath;
  176. char monat,jahr,tag,std,min,sec;
  177.  
  178. struct     modulhead {
  179.                         short       modulsync;
  180.                         short       modulrevision;
  181.                         int         modulsize;
  182.                         int         modulowner;
  183.                         int         modulnameoffset;
  184.                         short       modulaccess;
  185.                         char        modultype;
  186.                         char        modullanguage;
  187.                         char        modulattr;
  188.                         char        modulrevlevel;
  189.                         short       moduledition;
  190.  
  191.                   } *modaccess;
  192.  
  193.  
  194.      char *monate[] = {
  195. "Jan",
  196. "Feb",
  197. "Mar",
  198. "Apr",
  199. "May",
  200. "Jun",
  201. "Jul",
  202. "Aug",
  203. "Sep",
  204. "Oct",
  205. "Nov",
  206. "Dec"};
  207.  
  208.      char *termtype[] = {
  209. "VT100",
  210. "VT101",
  211. "VT102",
  212. "VT200",
  213. "VT220",
  214. "VT320"};
  215.  
  216. char badcode[] = "???";
  217.  
  218. char *ossvtble[] = 
  219. {
  220.     /*  service call codes 0-38  */
  221.    "Link",     "Load",     "Unlink",   "Fork",     "Wait",
  222.    "Chain",    "Exit",     "Mem",      "Send",     "Icpt",
  223.  
  224.    "Sleep",    "SSpd",     "ID",       "SPrior",   "STrap",
  225.    "PErr",     "PrsNam",   "CmpNam",   "SchBit",   "AllBit",
  226.  
  227.    "DelBit",   "Time",     "STime",    "CRC",      "GPrDsc",
  228.    "GBlkMap",  "GModDir",  "CpyMem",   "SUser",    "UnLoad",
  229.  
  230.    "RTE",      "GPrDBT",   "Julian",   "TLink",    "DFork",
  231.    "DExec",    "DExit",    "DatMod",   "SetCRC",    "SetSys",
  232.  
  233.    "SRqMem",   "SRtMem",   "IRQ",      "IOQu",     "AProc",
  234.    "NProc",    "VModul",   "Find64",   "All64",    "Ret64",
  235.  
  236.    "SSvc",     "IODel",    "SLink",    badcode,    badcode,
  237.    "GProcP",   "Move",     "AllRAM",
  238.  
  239.     /*  dummy entries 58-74  */
  240.    badcode,    badcode,    badcode,    badcode,    badcode,
  241.    badcode,    badcode,    badcode,    badcode,    badcode,
  242.    badcode,    badcode,    badcode,    badcode,    badcode,
  243.    badcode,    badcode,
  244.  
  245.     /*  service call codes 75-81  */
  246.    "AllPrc",   "DelPrc",   "ELink",    "FModul",   "MapBlk",
  247.    "ClrBlk",   "DelRAM",    "SysDbg",  "Event"
  248. };
  249.  
  250. char *osiotble[] = 
  251. {
  252.    "Attach",   "Detach",   "Dup",      "Create",   "Open",
  253.    "MakDir",   "ChgDir",   "Delete",   "Seek",     "Read",
  254.    "Write",    "ReadLn",   "WritLn",   "GetStt",   "SetStt",
  255.    "Close",    badcode,    badcode,    "SGetSt",
  256. };
  257.  
  258.     char hdr[] =
  259. "qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq"
  260. ;
  261.         char prozent[] =
  262. "0        25        50        75        100 %%";
  263.  
  264.         char loginfo[] =
  265. "\033[7;7m SYSMON: \033[0;0m  LOGFILE: '%s' open ! Size: %6d ";
  266.  
  267.         char referstr[] =
  268. "\033[7;7m CMD-REFERENCE: \033[0;0m [A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Z,+,-,<,>,1,2]";
  269.  
  270.         char maxhstr[] =
  271. "\007\033[7;7m\033[1;1m SYSMON: \033[0;0m MAX-HOLD-FUNCTION enabled !";
  272.  
  273.         char maxhdstr[] =
  274. "\007\033[7;7m SYSMON: \033[0;0m MAX-HOLD-FUNCTION disabled !";
  275.  
  276.         char kernstr[] =
  277. "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m This process can't be affected !";
  278.  
  279.         char tickswarnstr[]=
  280. "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON-ERROR: \033[0;0m Can't get time of systemtick !";
  281.  
  282.         char selectstring[]=
  283. "\033[7;7m\033[1;1m SYSMON: \033[0;0m \033[7;7mSelect:\033[0;0m '<'/'>' \033[7;7mKill:\033[0;0m 'K' \033[7;7mPrior:\033[0;0m 'T' \033[7;7mQuit:\033[0;0m 'S'  \033[7;7mSuspend/Enable:\033[0;0m 'O'\033[K";  
  284.  
  285.         char timeoutstr[]=
  286. "\033[K\007\033[7;7m\033[1;1m SYSMON: \033[0;0m Keyboard timeout period expired !\n";
  287.  
  288.         char undefkeystr[]=
  289. "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m Undefined key !";
  290.  
  291.         char termwarnstr[]=
  292. "SYSMON: Environment variable TERM not defined !";
  293.  
  294.         char jokestr[]=
  295. "\033[K\007\033[7;7m\033[5;5m\033[1;1m SYSMON-COMMENT: \033[0;0m You must be jokin , that's me !";
  296.  
  297.         char memprotstr[]=
  298. "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m This option does not work due to  MEMORYPROTECTION !";
  299.  
  300.         char mmu_errstr[]=
  301. "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON-FATAL-ERROR: \033[0;0m A MMU-ERROR occured !";
  302.  
  303.         char passfiledatestr[]=
  304. "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON-ERROR: \033[0;0m Can't determine passwordfile-date !";
  305.  
  306.         char readingpassstr[]=
  307. "\033[K\033[7;7m SYSMON: \033[0;0m reading password-file ...";
  308.  
  309.         char readpasserrstr[]=
  310. "\033[K\007\033[7;7m\033[1;1m SYSMON-WARNING : \033[0;0m password-file can't be read !!!";
  311.  
  312.         char readingmodipassstr[]=
  313. "\033[K\007\033[7;7m SYSMON: \033[0;0m reading modified password-file ...";
  314.  
  315.         char passworddatestr[]=
  316. "\033[K\007\033[7;7m SYSMON-WARNING: \033[0;0m passwordfile was modified at: ";
  317.  
  318.         char proofpassstr[]=
  319. "\033[K\033[7;7m SYSMON: \033[0;0m proofing password-file ...";
  320.  
  321.         char reached_endstr[]=
  322. "\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m Selected process reached end of processtable !\033[K";
  323.  
  324.         char reached_beginstr[]=
  325. "\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m Selected process reached begin of processtable !\033[K";
  326.  
  327.         char process_endstr[]=
  328. "\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m End of processtable reached !\033[K";
  329.  
  330.         char process_beginstr[]=
  331. "\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m Begin of processtable reached !\033[K";
  332.  
  333.         char scann_str[]=
  334. "\033[K\033[7;7m\033[1;1m\033[5;5m SYSMON-INFO: \033[0;0m Scanning processtable ... ";
  335.  
  336.  
  337. extern int os9fork();
  338.  
  339.   char *argblk[ARG_ENV_NUM];
  340.   char **environa;
  341.  
  342.   char error_indi=FALSE;
  343.   char ret_disp=0;  
  344.   char reference=FALSE;  
  345.   char unkown_flag=FALSE;  
  346.   char watchy_flag=FALSE;
  347.   char killit=FALSE;  
  348.   char maxh_flag=FALSE;
  349.   char default_flag=FALSE;
  350.   char reset_flag=TRUE;
  351.   char prillow=TRUE;  
  352.   char spr_flag=FALSE;
  353.   char killer=FALSE;
  354.  
  355.   float cpu_time[MAXPROCS];
  356.  
  357.   int tickspsecond=0;
  358.   int MAXIMUM_PROCS=0;  
  359.   int oldus,oldgrp;  
  360.   int indi=0, iolen[100], scc=1,fa=0,fb=0;
  361.   int maxprocent[MAXPROCS];
  362.  
  363.   remote char iobuf[MAXUSERS+1][100];    
  364.   remote char fildesbuffer[sizeof(struct fildes)];
  365.  
  366.   char initbuf[512];
  367.   char ddnam[60];
  368.   char nodedefnam[100];  
  369.   char passwordnam[100];
  370.   char os9vers[5];
  371.   char displaystring[255];
  372.   
  373.   char names[MAXPROCS][16], nodename[80];
  374.   remote char piopath[MAXPROCS][40];
  375.   unsigned short id[MAXPROCS],pid[MAXPROCS];
  376.   unsigned short group[MAXPROCS],user[MAXPROCS],prior[MAXPROCS];
  377.   unsigned int cpu_use[MAXPROCS], cpu_sys[MAXPROCS];
  378.   unsigned int rxbytes[MAXPROCS], txbytes[MAXPROCS];
  379.   unsigned int fca[MAXPROCS], ica[MAXPROCS];
  380.   unsigned int callnam[MAXPROCS];
  381.   unsigned short signal[MAXPROCS], cid[MAXPROCS];
  382.  
  383.   int estd[MAXPROCS], emin[MAXPROCS], esec[MAXPROCS];
  384.   int ustd[MAXPROCS], umin[MAXPROCS], usec[MAXPROCS];
  385.   int modsize[MAXPROCS], adress[MAXPROCS];
  386.   int revision[MAXPROCS], modown[MAXPROCS];  
  387.  
  388.   int i,imax=0,old_imax=0,bytes,pwh=FALSE;
  389.   int cpu_proc[MAXPROCS];
  390.   int lastcount=0;
  391.   int delay=2;
  392.   int myolddelay=2;
  393.   int olddelay=2;
  394.   int mindelay=1;  
  395.   int processor=0;
  396.   int act_task=0;
  397.   int oldact_task=0;
  398.   int actualcount=0;  
  399.   int markpr=99000;
  400.   int markprior;  
  401.   int porthandle;
  402.   int ownuid=0;
  403.   int ownprior=128;
  404.   int orginatprior=128;
  405.   int passerror=0;  
  406.   int oldprocs=0;
  407.   int mark_proc=0;
  408.   int maxage;
  409.   int oldmaxage=0;
  410.   int minage;
  411.   int oldminage=0;    
  412.   int suspendcount=0;  
  413.   int abortsig;
  414.   int quitsig;
  415.   int pausesig;
  416.   int eofsig;
  417.   int echosig;
  418.   int nodenamlen=0;
  419.   int filestd[2];
  420.   int filedate[2];
  421.   int login_old=0;
  422.   int login_new=0;
  423.  
  424.   char mark=0;  
  425.   char prior_flag=0;
  426.   char mode_flag=0;
  427.   char exmode=0;
  428.   char icpt_flag=0;
  429.   char active_flag=0;
  430.   char nodeflag=0;
  431.   char name_flag=TRUE;
  432.   char refresh_flag=FALSE;
  433.   char clflg=FALSE;
  434.   char susy_flag=FALSE;  
  435.   char bell=OFF;  
  436.   char startc=0;
  437.   char killnam[80];  
  438.   char privileg=FALSE;
  439.   char start_flag=FALSE;  
  440.   char remove_flag=FALSE;
  441.   char portnam[100];
  442.   char messagebuf[100];
  443.   char lastpassworddate[10];    
  444.  
  445. struct    sgbuf    oldstat, newstat ;
  446.   
  447.  
  448. /*---------------------------- BEGIN OF CODE ---------------------------------*/
  449. reseter()
  450. {
  451. /*
  452. *
  453. Reset_card:
  454. *    this sections resets the CPU card by software reset request.
  455. *
  456. *    reset remark H.W.Heyng 08/06/88 :
  457. *    The following reset sequence is developed/tested by F.R.Schmitt/W.Ott
  458. *    (and not fully understand but it works...).
  459. */
  460. #asm
  461.           move.l    #$4,a3
  462.           move.l    (a3),a1
  463.           move.l    #$bc,a3
  464.       move.l    (a3),d2
  465.       lea       reset_vek(pc),a0
  466.       move.l    a0,(a3)
  467.       move.l    #0,d1
  468.       trap      #15
  469. reset_vek:
  470.           reset
  471.       clr.l     d3
  472. reset_loop:
  473.           add.l     #1,d3
  474.       nop
  475.       cmp.l     #10000,d3
  476.       bne.s     reset_loop
  477.           move.l    #$bc,a3
  478.       move.l    d2,(a3)
  479.           move.l    #$0,a3
  480.       move.l    (a3),a7    
  481.       jmp       (a1)     
  482. #endasm
  483. }
  484.  
  485. desolatesystem()
  486. {
  487. #asm
  488. ********************************************************************************
  489. *
  490. * Name: Permit             NOTE: (undocumented system-call) !!!
  491. *
  492. * Description:
  493. * This function enables (from C) access to a given memory segment if
  494. * the system security module (ssm) is installed.
  495. *
  496. * Call:
  497. *      Permit(addr,len,perm)
  498. *
  499. * Arguments:
  500. *      char *addr       start address of memory segment,
  501. *                       rounded down to a multiple of 4096
  502. *      int len          length of memory segment,
  503. *                       rounded up to a multiple of 4096
  504. *      int perm         access permissions
  505. *  
  506. * Return values:
  507. *      0  if successfull
  508. *     -1  if an error occurred (error number is loaded in global variable errno)
  509. *
  510. ********************************************************************************
  511. Permit:
  512.          link.w a5,#0                     * link frame pointer
  513.          movem.l  d1-d2/a0/a2,-(sp)       * save used registers
  514.          movea.l d0,a2                    * load a2 with startaddress
  515.          move.l  d1,d0                    * load d0 with len
  516.          move.l  8(a5),d1                 * load d1 with permissions
  517.          OS9 F$Permit                     * call F$Permit
  518.          bcc.b Pe_noerr                   * if carry==1 skip to error label
  519.          move.l d1,errno(a6)              * store d1 in global errno variable
  520.          moveq #-1,d0                     * function error return value
  521.          bra.b Pe_ret
  522. Pe_noerr moveq #0,d0                      * function ok return value
  523. Pe_ret   movem.l  (sp)+,d1-d2/a0/a2       * return used registers
  524.          unlk a5                          * unlink frame pointer
  525.          rts                              * return from function
  526.  
  527. ********************************************************************************
  528. *
  529. * Name: Protect
  530. *
  531. * Description:
  532. * This function disables (from C) access to a given memory segment if
  533. * the system security module (ssm) is installed.
  534. * 
  535. *
  536. * Call:
  537. *      Protect(addr,len)
  538. *
  539. * Arguments:
  540. *      char *addr       start address of memory segment
  541. *                       rounded down to a multiple of 4096
  542. *      int len          length of memory segment
  543. *                       rounded up to a multiple of 4096
  544. *  
  545. * Return values:
  546. *      0  if successfull
  547. *     -1  if an error occurred (error number is loaded in global variable errno)
  548. *
  549. ********************************************************************************
  550. Protect:
  551.          link.w a5,#0                     * link frame pointer
  552.          movem.l  d1-d2/a0/a2,-(sp)       * save used registers
  553.          movea.l d0,a2                    * load a2 with startaddress
  554.          move.l  d1,d0                    * load d0 with len
  555.          OS9 F$Protect                    * call F$Protect
  556.          bcc.b Pr_noerr                   * if carry==1 skip to error label
  557.          move.l d1,errno(a6)              * store d1 in global errno variable
  558.          moveq #-1,d0                     * function error return value
  559.          bra.b Pr_ret
  560. Pr_noerr moveq #0,d0                      * function ok return value
  561. Pr_ret   movem.l  (sp)+,d1-d2/a0/a2       * return used registers
  562.          unlk a5                          * unlink frame pointer
  563.          rts                              * return from function
  564. #endasm
  565. }
  566. /*----------------------------------------------------------------------------*/
  567. /* name: BUSTRAPERROR - HANDLER - ROUTINE                                     */
  568. /* function: routine checks if adress is valid or not !                       */
  569. /* by: F.SCHMITT                                                              */ 
  570. /* Date: 02-04-88                                                             */
  571. /*----------------------------------------------------------------------------*/
  572. bustraphandler()
  573. {
  574. #asm
  575.         align
  576. checkadr:
  577.         movem.l  a0-a6/d1-d7,-(sp)
  578.         move.l   #0,a0
  579.         lea      table(pc),a1
  580.         os9      F$STrap
  581.  
  582.         move.l   d0,a0
  583.         move.b   (a0),d1
  584.         move.l   #0,d0
  585.         move.l   #0,d1
  586. return:    
  587.         move.l   #0,a0
  588.         lea      notable(pc),a1
  589.         os9      F$STrap
  590.         movem.l  (sp)+,a0-a6/d1-d7
  591.         rts
  592.  
  593.         align
  594. buserror     movem.l  (a5)+,d0-d7/a0-a7
  595.         move.l   #255,d0                
  596.         bra.s    return
  597.  
  598.         align
  599. table        dc.w  T_BusErr,buserror-*-4
  600.         dc.w  -1
  601.     
  602.         align    
  603. notable         dc.w  T_BusErr,0
  604.         dc.w  -1
  605. #endasm
  606. }
  607.  
  608. /*-------------------------------------------------------------------------*/
  609. iocalc()
  610. {
  611. #asm
  612.  
  613.     ttl sgetst(pathnum,bufptr) - get path name
  614.  
  615. sgetst:
  616.     movem.l   a0-a6/d2-d7,-(sp)
  617.     move.l    d1,a0         get address of buffer
  618.     move.l       #SS_DevNm,d1 
  619.     OS9       I$SGetSt
  620.     bcc.s     noerror
  621.     moveq     #-1,d0
  622.         move.w    d1,errno(a6)
  623. noerror    ext.l     d0
  624.     movem.l   (sp)+,a0-a6/d2-d7
  625.         rts
  626. #endasm
  627. }
  628. /*-------------------------------------------------------------------------*/
  629. tmode(pausesw,echosw)
  630. register char pausesw;
  631. register char echosw;
  632. {
  633.     _gs_opt(0, &newstat);
  634.         
  635.     newstat.sg_echo = echosw;
  636.     newstat.sg_pause=pausesw;
  637.  
  638.     _ss_opt(0, &newstat);
  639. }
  640. /*-------------------------------------------------------------------------*/
  641. switch_ctrl(on)
  642. register int on;
  643. {
  644.         switch(on)      
  645.         {
  646.             case ON:
  647.             _gs_opt(0, &newstat);
  648.             newstat.sg_kbich=quitsig;    /* keyboard interrupt character */
  649.             newstat.sg_kbach=abortsig;    /* keyboard abort character */
  650.                 newstat.sg_eofch=eofsig;        /* keyboard eof character   */
  651.             _ss_opt(0, &newstat);
  652.                 break;
  653.  
  654.             case OFF:
  655.             _gs_opt(0, &newstat);
  656.             newstat.sg_kbich=0;        /* keyboard interrupt character */
  657.             newstat.sg_kbach=0;        /* keyboard abort character */
  658.                 newstat.sg_eofch=0;             /* keyboard eof character   */
  659.             _ss_opt(0, &newstat);
  660.                 break;
  661.  
  662.             case RESTORE:
  663.             _gs_opt(0, &newstat);
  664.             _gs_opt(0, &oldstat);
  665.  
  666.             newstat.sg_kbich=quitsig;    /* keyboard interrupt character */
  667.             oldstat.sg_kbich=quitsig;    /* keyboard interrupt character */
  668.             newstat.sg_kbach=abortsig;    /* keyboard abort character */
  669.             oldstat.sg_kbach=abortsig;    /* keyboard abort character */
  670.                 newstat.sg_echo=echosig;        /* keyboard echo on/off     */
  671.                 oldstat.sg_echo=echosig;        /* keyboard echo on/off     */
  672.             newstat.sg_pause=pausesig;      /* keyboard pause on/off    */
  673.             oldstat.sg_pause=pausesig;      /* keyboard pause on/off    */
  674.                 newstat.sg_eofch=eofsig;      /* keyboard eof character   */
  675.                 oldstat.sg_eofch=eofsig;      /* keyboard eof character   */
  676.  
  677.             _ss_opt(0, &newstat);
  678.             _ss_opt(0, &oldstat);
  679.                 break;
  680.  
  681.             case GET:
  682.             _gs_opt(0, &oldstat);
  683.                 quitsig=oldstat.sg_kbich;    /* keyboard interrupt character */
  684.             abortsig=oldstat.sg_kbach;    /* keyboard abort character */
  685.                 echosig=oldstat.sg_echo;        /* keyboard echo on/off     */
  686.             pausesig=oldstat.sg_pause;      /* keyboard pause on/off    */
  687.                 eofsig=oldstat.sg_eofch;      /* keyboard eof character   */
  688.                 break;
  689.         }
  690. }
  691. /*-------------------------------------------------------------------------*/
  692. cls()
  693. {
  694.   printf("\033[2J\033[1;H");
  695.   if(logindi)  
  696.     fprintf(lpp,"\033[2J\033[1;H");
  697. }
  698. /*-------------------------------------------------------------------------*/
  699. wrap_off()
  700. {
  701.       printf("\033[?7l");        /* set terminal to NOWRAP ! */
  702.       if(logindi)
  703.           fprintf(lpp,"\033[?7l");        /* set terminal to NOWRAP ! */
  704. }
  705. /*-------------------------------------------------------------------------*/
  706. gotoxy(x,y)
  707. register char x,y;
  708. {
  709.   printf("\033[%d;%dH",y,x);
  710.   fflush(stdout);
  711.   if(logindi)
  712.   {    
  713.     fprintf(lpp,"\033[%d;%dH",y,x);
  714.     fflush(lpp);
  715.   }  
  716. }
  717. /*-------------------------------------------------------------------------*/
  718. effect()
  719. {
  720.     register char i;
  721.  
  722.     for(i=0;i<12;i++)
  723.     {
  724.         gotoxy(1,12+i);
  725.         printf("\033[K\n");
  726.         if(logindi)
  727.             fprintf(lpp,"\033[K\n");
  728.         gotoxy(1,12-i);
  729.         printf("\033[K\n");
  730.         if(logindi)
  731.             fprintf(lpp,"\033[K\n");
  732.     }
  733. }
  734. /*-------------------------------------------------------------------------*/
  735. uppercase(buf)
  736. register char *buf;
  737. {
  738.     register char *a;
  739.     a=buf;
  740.     do
  741.     {
  742.         *a=toupper(*a);
  743.         a++;
  744.     }while(*a !=0);
  745. }
  746. /*-------------------------------------------------------------------------*/
  747. disp_user(di)
  748. register int di;
  749. {
  750.     char cmpbuf[100];
  751.     char usernam[100];
  752.  
  753.     register int sch, fi, slen;
  754.     int cmphandle, cmplen, uselen;
  755.  
  756.     if(user[di]==0 && group[di]==0)
  757.     {
  758.         printf("SYSTEM      ");
  759.         if(logindi)
  760.             fprintf(lpp,"SYSTEM      ");
  761.         return(TRUE);
  762.     }
  763.     else
  764.     {
  765.         sprintf(cmpbuf,",%d.%d,",group[di],user[di]);
  766.         cmplen=strlen(cmpbuf);
  767.  
  768.         for(sch=0;sch<=indi;sch++)    
  769.         {
  770.             slen=strlen(&iobuf[sch][0]);
  771.             for(fi=0;fi<=slen;fi++)
  772.             {
  773.                 cmphandle=strncmp(cmpbuf,&iobuf[sch][fi],cmplen);
  774.                 if(!cmphandle)
  775.                 {
  776.                     for(uselen=0;uselen<=100;uselen++)                     
  777.                     {
  778.                         if(iobuf[sch][uselen]==',')
  779.                             break;
  780.                     }
  781.                     if(!uselen)
  782.                         sprintf(usernam,"\033[7;7m<UNKOWN>\033[0;0m    ");
  783.                     else
  784.                     {
  785.                         strncpy(usernam,&iobuf[sch][0],uselen);
  786.                         usernam[uselen]=0;
  787.                         uppercase(usernam);
  788.                     }
  789.                     printf("%-11s ",usernam);
  790.                     if(logindi)
  791.                         fprintf(lpp,"%-11s ",usernam);
  792.                     sch=indi;
  793.                     return(TRUE);
  794.                 }
  795.             }   
  796.         }
  797.         sprintf(usernam,"\033[7;7m<UNKOWN>\033[0;0m    ");
  798.         printf("%-11s",usernam);
  799.         if(logindi)
  800.             fprintf(lpp,"%-11s",usernam);
  801.         if(!unkown_flag)
  802.             unkown_flag=TRUE;
  803.         return(FALSE);
  804.     }
  805. }
  806. /*-------------------------------------------------------------------------*/
  807. get_passworddate(dateindex)
  808. register int dateindex;
  809. {
  810.     register int fph;
  811.     register struct fildes *filpoi;
  812.  
  813.  
  814.     filpoi=(struct fildes *) fildesbuffer;
  815.  
  816.     fph=open(passwordnam,1);
  817.     if(fph==-1)
  818.     {
  819.         gotoxy(1,23);
  820.         printf("%s\n",passfiledatestr);
  821.       if(logindi)
  822.             fprintf(lpp,"%s\n",passfiledatestr);
  823.         sleep(2);
  824.         return(-1);
  825.     }
  826.  
  827.     if(_gs_gfd(fph,fildesbuffer,sizeof(struct fildes))==-1)
  828.     {
  829.         close(fph);
  830.         gotoxy(1,23);
  831.             printf("%s\n",passfiledatestr);
  832.       if(logindi)
  833.             fprintf(lpp,"%s\n",passfiledatestr);
  834.         sleep(2);
  835.         return(-1);
  836.     }
  837.  
  838.     filestd[dateindex]=
  839.     (filpoi->fd_date[4]) +
  840.     (filpoi->fd_date[3])*100;
  841.  
  842.     filedate[dateindex]=
  843.     (filpoi->fd_date[2]) +
  844.     (filpoi->fd_date[1])*100 +
  845.     (filpoi->fd_date[0])*10000;
  846.  
  847.     lastpassworddate[0]=filpoi->fd_date[2];
  848.     lastpassworddate[1]=filpoi->fd_date[1];
  849.     lastpassworddate[2]=filpoi->fd_date[0];
  850.     lastpassworddate[3]=filpoi->fd_date[3];
  851.     lastpassworddate[4]=filpoi->fd_date[4];
  852.  
  853.     close(fph);
  854.     return(0);
  855. }
  856. /*-------------------------------------------------------------------------*/
  857. get_password()
  858. {
  859.    register int fh, rh, koma1,koma2;
  860.    register char exeed_flag=FALSE; 
  861.  
  862.    passerror=0;
  863.    indi=0;
  864.  
  865.    if(chmod(passwordnam,0x09)==-1)
  866.    {
  867.         passerror=errno; 
  868.         return(FALSE);
  869.    }
  870.  
  871.    fh=open(passwordnam,1);
  872.    if(fh==-1)
  873.    {
  874.         passerror=errno;
  875.         return(FALSE);
  876.    }   
  877.  
  878.    for(;;)
  879.    {
  880.       rh=readln(fh,&iobuf[indi][0],100);
  881.       iolen[indi]=rh;
  882.       if(rh==0 || rh==-1)
  883.          break;
  884.  
  885.       koma1=findstr(1,&iobuf[indi][0],",");
  886.       koma2=findstr(koma1+1,&iobuf[indi][0],",");
  887.  
  888.       /* this is for that people can't look into the memory and see all the
  889.          passwords in the passwordfile !    */    
  890.       if(koma2>koma1+1)                        /* minimum 1 character ! */
  891.       {
  892.         for(rh=koma1;rh<koma2-1;rh++)
  893.             iobuf[indi][rh]='?';
  894.       }    
  895.  
  896.       indi++;   
  897.  
  898.       if(indi>MAXUSERS)
  899.       {
  900.         exeed_flag=TRUE;
  901.         gotoxy(1,23);
  902.         printf("\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON-ERROR: \033[0;0m Sorry passwordfile has more then %d entrys !\n",
  903.         MAXUSERS);
  904.         if(logindi)
  905.             fprintf(lpp,"\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON-ERROR: \033[0;0m Sorry passwordfile has more then %d entrys !\n",
  906.             MAXUSERS);
  907.         error_indi=TRUE;
  908.         sleep(2);
  909.         break;
  910.       }
  911.    }
  912.    close(fh);
  913.  
  914.    if(get_passworddate(0)==-1)
  915.       exeed_flag=TRUE;     
  916.  
  917.    if(chmod(passwordnam,0x01)==-1)
  918.    {
  919.       passerror=errno;
  920.       return(FALSE);
  921.    }
  922.  
  923.    if(icpt_flag==TRUE)
  924.    {
  925.       fflush(stdout);    
  926.       return(FALSE);
  927.    }
  928.  
  929.    if(exeed_flag)
  930.     return(FALSE);
  931.    else 
  932.     return(TRUE); 
  933. }  
  934. /*-------------------------------------------------------------------------*/
  935. under_title()
  936. {
  937.     register int actualis;
  938.  
  939.             if(imax+1>=actualcount+16)
  940.                   actualis=16;
  941.             else
  942.                 actualis=imax+1-actualcount;
  943.             
  944.             fa=actualcount;
  945.             fb=actualis;
  946.  
  947.             if(killer || spr_flag)  /* forbid undertitle when you are */
  948.                 return(0);          /* in question mode ! [Y/N]       */
  949.  
  950.             gotoxy(1,23);
  951.  
  952.             if(!start_flag)
  953.             {
  954.                 printf("%s\n",scann_str);
  955.                 if(logindi)
  956.                     fprintf(lpp,"%s\n",scann_str);
  957.                 return(0);
  958.             }
  959.  
  960.             if(reference)
  961.             {
  962.                 printf("\033[K%s \n",referstr);
  963.                 if(logindi)
  964.                     fprintf(lpp,"\033[K%s \n",referstr);
  965.                 return(0);
  966.             }
  967.  
  968.             if(maxh_flag)
  969.             {
  970.                 printf("\033[K%s \n",maxhstr);
  971.                 if(logindi)
  972.                     fprintf(lpp,"\033[K%s \n",maxhstr);
  973.                 return(0);
  974.             }
  975.  
  976.             if(logindi && !susy_flag)
  977.             {
  978.                 printf(loginfo,logfilenam,logfilesize);
  979.                 fprintf(lpp,loginfo,logfilenam,logfilesize);
  980.                 return(0);
  981.             }
  982.  
  983.             if(nodeflag)
  984.             {
  985.                 if(!susy_flag)
  986.                 {
  987.                     if(!active_flag)
  988.                     {
  989.                         printf("\033[KSYSMON %s    What's happening on %s                Processes: %3d+ %d \n",
  990.                         versi,nodename,actualcount,actualis);
  991.                         if(logindi)
  992.                             fprintf(lpp,"\033[KSYSMON %s    What's happening on %s                Processes: %3d+ %d \n",
  993.                             versi,nodename,actualcount,actualis);
  994.                     }
  995.                     else
  996.                     {
  997.                         printf("\033[KSYSMON %s    What's happening on %s           User-Processes: %3d+ %d \n",
  998.                         versi,nodename,actualcount,actualis);
  999.                         if(logindi)
  1000.                             fprintf(lpp,"\033[KSYSMON %s    What's happening on %s           User-Processes: %3d+ %d \n",
  1001.                             versi,nodename,actualcount,actualis);
  1002.                     }
  1003.                 }
  1004.                 else
  1005.                 {
  1006.                     printf("%s\n",selectstring);
  1007.                     if(logindi)
  1008.                         fprintf(lpp,"%s\n",selectstring);
  1009.                 }  
  1010.             }
  1011.             else
  1012.             {
  1013.                 if(!susy_flag)
  1014.                 {
  1015.                     if(!active_flag)
  1016.                     {
  1017.                     printf("\033[KSYSMON %s                                          Processes: %3d+ %d \n",
  1018.                         versi,actualcount,actualis);
  1019.                         if(logindi)
  1020.                         fprintf(lpp,"\033[KSYSMON %s                                          Processes: %3d+ %d \n",
  1021.                             versi,actualcount,actualis);
  1022.                     }
  1023.                     else
  1024.                     {
  1025.                     printf("\033[KSYSMON %s                                     User-Processes: %3d+ %d \n",
  1026.                         versi,actualcount,actualis);
  1027.                         if(logindi)
  1028.                         fprintf(lpp,"\033[KSYSMON %s                                     User-Processes: %3d+ %d \n",
  1029.                             versi,actualcount,actualis);
  1030.                     }
  1031.                 }  
  1032.                 else
  1033.                 {
  1034.                     printf("%s\n",selectstring);
  1035.                     if(logindi)
  1036.                            fprintf(lpp,"%s\n",selectstring);
  1037.                 }  
  1038.             }
  1039. }
  1040. /*-------------------------------------------------------------------------*/
  1041. display_frame()
  1042. {
  1043.   register int i;
  1044.  
  1045.   cursoroff();
  1046.   wrap_off();  
  1047.   cls();
  1048.   gotoxy(24,0);
  1049. #ifdef DEMO
  1050.   printf("OS9/68k %s Process Monitor Demo %s \n",os9vers,versi);
  1051.   if(logindi)  
  1052.     fprintf(lpp,"OS9/68k %s Process Monitor Demo %s \n",os9vers,versi);
  1053. #else
  1054.   printf("OS9/68k %s Process Monitor %s \n",os9vers,versi);
  1055.   if(logindi)  
  1056.     fprintf(lpp,"OS9/68k %s Process Monitor %s \n",os9vers,versi);
  1057. #endif
  1058.   display_time();
  1059.   printf("\n");
  1060.   if(logindi)
  1061.     fprintf(lpp,"\n");
  1062.   gotoxy(37,4);
  1063.   printf("%s\n",prozent);
  1064.   if(logindi)
  1065.     fprintf(lpp,"%s\n",prozent);
  1066.   gotoxy(1,5);
  1067.  
  1068.   if(name_flag)
  1069.   {  
  1070.     printf("Id  Username   Processname");
  1071.     if(logindi)
  1072.         fprintf(lpp,"Id  Username   Processname");
  1073.   }
  1074.   else
  1075.   {
  1076.     if(prior_flag)
  1077.     {
  1078.         printf("Id  Prior      Processname");
  1079.         if(logindi)
  1080.                fprintf(lpp,"Id  Prior      Processname");
  1081.     }
  1082.     else
  1083.     {
  1084.         printf("Id Grp.Usr     Processname");
  1085.         if(logindi)
  1086.             fprintf(lpp,"Id Grp.Usr     Processname");
  1087.     }  
  1088. }
  1089.   gotoxy(37,5);
  1090.   printf("\033(0tqqqqqqqqqnqqqqqqqqqnqqqqqqqqqnqqqqqqqqqqu\033(B\n");
  1091.   if(logindi)  
  1092.     fprintf(lpp,"\033(0tqqqqqqqqqnqqqqqqqqqnqqqqqqqqqnqqqqqqqqqqu\033(B\n");
  1093.   for(i=1;i<=16;i++)
  1094.   {
  1095.     gotoxy(37,5+i);
  1096.     printf("\033(0x");
  1097.     if(logindi) 
  1098.         fprintf(lpp,"\033(0x");
  1099.     gotoxy(47,5+i);
  1100.     printf("\033(0x");
  1101.     if(logindi) 
  1102.         fprintf(lpp,"\033(0x");
  1103.     gotoxy(57,5+i);
  1104.     printf("\033(0x");
  1105.     if(logindi)
  1106.         fprintf(lpp,"\033(0x");
  1107.     gotoxy(67,5+i);
  1108.     printf("\033(0x");
  1109.     if(logindi)
  1110.         fprintf(lpp,"\033(0x");
  1111.     gotoxy(78,5+i);
  1112.     printf("x\033(B\n");
  1113.     if(logindi)
  1114.         fprintf(lpp,"x\033(B\n");
  1115.   }
  1116.   gotoxy(37,22);
  1117.   printf("\033(0tqqqqqqqqqnqqqqqqqqqnqqqqqqqqqnqqqqqqqqqqu\033(B\n");
  1118.   if(logindi)  
  1119.     fprintf(lpp,"\033(0tqqqqqqqqqnqqqqqqqqqnqqqqqqqqqnqqqqqqqqqqu\033(B\n");
  1120.  
  1121.  
  1122.   if(logindi)
  1123.   {
  1124.     gotoxy(1,23);
  1125.     printf(loginfo,logfilenam,logfilesize);
  1126.     printf("\n");
  1127.     fprintf(lpp,loginfo,logfilenam,logfilesize);
  1128.     fprintf(lpp,"\n");
  1129.     return(0);
  1130.   }
  1131.  
  1132.   if(reference)
  1133.   {
  1134.     gotoxy(1,23);
  1135.     printf("\033[K%s\n",referstr);
  1136.     if(logindi)
  1137.         fprintf(lpp,"\033[K%s\n",referstr);
  1138.   }
  1139.   else
  1140.   {  
  1141.     if(maxh_flag)
  1142.     {
  1143.         gotoxy(1,23);
  1144.            printf("\033[K%s \n",maxhstr);
  1145.         if(logindi)
  1146.                fprintf(lpp,"\033[K%s \n",maxhstr);
  1147.     }
  1148.     else
  1149.     {
  1150.         gotoxy(37,23);
  1151.         printf("%s\n",prozent);
  1152.         if(logindi)
  1153.             fprintf(lpp,"%s\n",prozent);
  1154.     }
  1155.   }
  1156. }
  1157. /*-------------------------------------------------------------------------*/
  1158. display_dframe()
  1159. {
  1160.   cursoron();
  1161.   wrap_off();  
  1162.   cls();
  1163.   gotoxy(24,0);
  1164. #ifdef DEMO
  1165.   printf("OS9/68k %s Process Monitor Demo %s \n",os9vers,versi);
  1166.   if(logindi)  
  1167.     fprintf(lpp,"OS9/68k %s Process Monitor Demo %s \n",os9vers,versi);
  1168. #else
  1169.   printf("OS9/68k %s Process Monitor %s \n",os9vers,versi);
  1170.   if(logindi)  
  1171.     fprintf(lpp,"OS9/68k %s Process Monitor %s \n",os9vers,versi);
  1172. #endif
  1173.   display_time();
  1174.   gotoxy(1,4);  
  1175.   if(pwh && name_flag)
  1176.   {
  1177.     switch (exmode)
  1178.     {
  1179.         case 0:
  1180.             printf("Id  Pid  Username    Processname      Rxbytes  Txbytes  Cpu_System Cpu_User  CPU\n");
  1181.             if(logindi)
  1182.                    fprintf(lpp,"Id  Pid  Username    Processname      Rxbytes  Txbytes  Cpu_System Cpu_User  CPU\n");
  1183.             break;
  1184.         case 1:
  1185.           printf("Id  Pid  Username    Processname       Icalls   Fcalls Last   Signal  Child  CPU\n");
  1186.             if(logindi)
  1187.                    fprintf(lpp,"Id  Pid  Username    Processname       Icalls   Fcalls Last   Signal  Child  CPU\n");
  1188.             break;
  1189.         case 2:
  1190.           printf("Id  Pid  Username    Processname      MemAdr$  ModSize  Edition  ModulOwner  CPU\n");
  1191.             if(logindi)
  1192.               fprintf(lpp,"Id  Pid  Username    Processname      MemAdr$  ModSize  Edition  ModulOwner  CPU\n");
  1193.             break;
  1194.         case 3:
  1195.           printf("Id  Pid  Username    Processname     IO-Path                                 CPU\n");
  1196.             if(logindi)
  1197.               fprintf(lpp,"Id  Pid  Username    Processname     IO-Path                                 CPU\n");
  1198.             break;
  1199.     }  
  1200.   }
  1201.   else
  1202.   {
  1203.     switch (exmode)
  1204.     {
  1205.         case 0:
  1206.             printf("Id  Pid  prior  Own  Processname      Rxbytes  Txbytes  Cpu_Sys    Cpu_user  CPU\n");
  1207.             if(logindi)
  1208.                 fprintf(lpp,"Id  Pid  prior  Own  Processname      Rxbytes  Txbytes  Cpu_Sys    Cpu_user  CPU\n");
  1209.             break;
  1210.         case 1:
  1211.           printf("Id  Pid  prior  Own  Processname       Icalls   Fcalls Last   Signal  Child  CPU\n");
  1212.             if(logindi)
  1213.               fprintf(lpp,"Id  Pid  prior  Own  Processname       Icalls   Fcalls Last   Signal  Child  CPU\n");
  1214.             break;
  1215.         case 2:
  1216.           printf("Id  Pid  prior  Own  Processname      MemAdr$  ModSize  Edition  ModulOwner  CPU\n");
  1217.             if(logindi)
  1218.               fprintf(lpp,"Id  Pid  prior  Own  Processname      MemAdr$  ModSize  Edition  ModulOwner  CPU\n");
  1219.             break;
  1220.         case 3:
  1221.           printf("Id  Pid  prior  Own  Processname     IO-Path                                 CPU\n");
  1222.             if(logindi)
  1223.               fprintf(lpp,"Id  Pid  prior  Own  Processname     IO-Path                                 CPU\n");
  1224.             break;
  1225.     }  
  1226.   }
  1227.   printf ("\033(0");
  1228.   printf ("%s",hdr);
  1229.   printf ("\033(B\n");
  1230.   if(logindi)
  1231.   {    
  1232.     fprintf (lpp,"\033(0");
  1233.     fprintf (lpp,"%s",hdr);
  1234.     fprintf (lpp,"\033(B\n");
  1235.   }  
  1236.   gotoxy(0,22);
  1237.   printf ("\033(0");
  1238.   printf ("%s",hdr);
  1239.   printf ("\033(B\n");
  1240.   if(logindi)
  1241.   {    
  1242.     fprintf (lpp,"\033(0");
  1243.     fprintf (lpp,"%s",hdr);
  1244.     fprintf (lpp,"\033(B\n");
  1245.   }  
  1246.   under_title();
  1247. }
  1248. /*---------------------------------------------------------------------------*/
  1249. gotsignl(signum)
  1250. register int signum;
  1251. {
  1252.   if(signum!=DATAPRESENT)
  1253.     return(0);
  1254.  
  1255.   if(error_indi)  
  1256.     ret_disp++;  
  1257.   icpt_flag=TRUE;  
  1258. }      
  1259. /*---------------------------------------------------------------------------*/
  1260. getiopaths(descptr,piopp)
  1261. register procid *descptr;
  1262. register char *piopp;
  1263. {
  1264.     register int i,path,x;
  1265.     mod_exec *mod ;
  1266.     char namebuf[33];
  1267.     
  1268.     static char *stds[] = 
  1269.     {
  1270.       "<", ">", ">>"
  1271.     };
  1272.  
  1273.     *piopp=0;
  1274.     mod = descptr->_pmodul;
  1275.     for (i = 0; i < 3; i++) 
  1276.     {
  1277.         if ((path = descptr->_path[i]) != 0)
  1278.         {
  1279.               if (sgetst(path,namebuf) != -1)
  1280.             {
  1281.                   for (x = i; x < 3; x++)
  1282.                 { 
  1283.                     if (descptr->_path[x] == path) 
  1284.                       {
  1285.                         strcat(piopp,stds[x]);
  1286.                         descptr->_path[x] = 0;
  1287.                       }
  1288.                 }
  1289.                   strcat(piopp,namebuf);
  1290.                   strcat(piopp," ");
  1291.             }
  1292.         }
  1293.     }
  1294.     uppercase(piopp);
  1295. }
  1296. /*---------------------------------------------------------------------------*/
  1297. get_ticktime()
  1298. {
  1299.     int time, date,tick;
  1300.     short day;
  1301.  
  1302.     if((_sysdate(3,&time,&date,&day,&tick))==-1)
  1303.     {
  1304.         tmode(0,1);
  1305.         cursoron();
  1306.         printf("%s\n",tickswarnstr);        
  1307.         switch_ctrl(RESTORE);
  1308.         if(strncmp(portnam,"PKS",3)==0)
  1309.             sleep(2);
  1310.         exit(errno);
  1311.     }
  1312.     tickspsecond=(tick>>16) & 0xffff;
  1313.     if(tickspsecond<1)
  1314.     {
  1315.         tmode(0,1);
  1316.         cursoron();
  1317.         printf("\033[K\007\033[7;7m SYSMON-ERROR: \033[0;0m Illegal tickcount/second %d !!!\n",tickspsecond);        
  1318.         switch_ctrl(RESTORE);
  1319.         if(strncmp(portnam,"PKS",3)==0)
  1320.             sleep(2);
  1321.         exit(0);
  1322.     }
  1323. }
  1324. /*---------------------------------------------------------------------------*/
  1325. get_cputime()
  1326. {
  1327.   register int i, j=0, maxip=0, calcrest;
  1328.   register char *modadr;
  1329.  
  1330.   char *nameadr;
  1331.   unsigned int ticks[2][MAXPROCS];
  1332.   char newnames[20], internames[20];  
  1333.   char workbuff[100];
  1334.   unsigned short proctab[400];
  1335.   register struct pdsc *pr;
  1336.   int rrprior;    
  1337.   float all_cpu;
  1338.  
  1339.   suspendcount=0;
  1340.  
  1341.   if(logindi && !reference && !susy_flag && ! maxh_flag)
  1342.   {
  1343.         logfilesize=_gs_size(logpath);
  1344.         if(logfilesize==-1)
  1345.         {
  1346.             logindi=FALSE;
  1347.             fclose(lpp);
  1348.         }
  1349.         else
  1350.         {
  1351.             if(logfilesize>=MAXLOGSIZE)
  1352.             {
  1353.                 logindi=FALSE;
  1354.                 fclose(lpp);
  1355.                     close(logpath);        
  1356.                     gotoxy(1,23);
  1357.                     printf("\033[K\007\033[7;7m SYSMON-INFO: \033[0;0m logfile: '%s' full, capture closed !\n",logfilenam);
  1358.                     sleep(2);
  1359.                     error_indi=TRUE;
  1360.             }
  1361.             else
  1362.             {
  1363.                 gotoxy(1,23);
  1364.                 printf(loginfo,logfilenam,logfilesize);
  1365.                 fprintf(lpp,loginfo,logfilenam,logfilesize);
  1366.             }
  1367.         }
  1368.  
  1369.   }  
  1370.  
  1371.   pr = (struct pdsc *)proctab;
  1372.   
  1373.   for(i=1;i<=MAXPROCS;i++)              /* At first see how many processes */
  1374.   {                                       /* are running on the system !     */
  1375.         bytes = _get_process_desc(i,1,pr);
  1376.         if(bytes!=-1)
  1377.             maxip=i;
  1378.   }
  1379.  
  1380.     
  1381.   if(privileg && prillow)                /* rise priority to high value !   */  
  1382.     setpr(ownuid,65535);
  1383.   
  1384.   for(i=1;i<=maxip;i++)                    /* NOW SCANN ALL PROCESSES 1. TIME */
  1385.   {
  1386.     if(i%50==0)       /* if there are many processes don't consume to much CPU */
  1387.         tsleep(2);
  1388.  
  1389.     bytes = _get_process_desc(i,800, pr);
  1390.     if(bytes != -1)
  1391.     {    
  1392.       modadr = (char *)pr->_pmodul;
  1393.             
  1394.       if(modadr!=0)
  1395.       {
  1396.           _cpymem(pr->_pid, 4, modadr+0xc, &nameadr); 
  1397.           nameadr += (int)modadr;
  1398.           _cpymem(pr->_pid,16, nameadr,internames);
  1399.         internames[16]=0;
  1400.         strcpy(names[j],internames);
  1401.           uppercase(names[j]);    
  1402.       }    
  1403.       else
  1404.         sprintf(names[j],"<NONE>");
  1405.  
  1406.  
  1407.       id[j]=bytes;
  1408.       group[j]=pr->_group;
  1409.       user[j]=pr->_user;
  1410.       pid[j]=pr->_pid;
  1411.  
  1412.       getiopaths(pr,piopath[j]);
  1413.  
  1414.       if(id[j]==ownuid && privileg && prillow)
  1415.         prior[j]=ownprior;
  1416.       else
  1417.       {    
  1418.           prior[j]=pr->_prior;
  1419.         if(prior[j]==0 && minage==1)
  1420.             suspendcount++;
  1421.       }
  1422.  
  1423.       if(remove_flag)                /* that's for clearing the 0 priority */
  1424.       {    
  1425.         rrprior=pr->_prior;
  1426.           if(rrprior==0)
  1427.                  setpr(id[j],STANDARDPRIOR);
  1428.       }
  1429.  
  1430.       cpu_sys[j]=(unsigned int)pr->_sticks;
  1431.       estd[j]=cpu_sys[j]/(3600*tickspsecond);
  1432.       calcrest=cpu_sys[j]%(3600*tickspsecond);
  1433.       emin[j]=(calcrest/(60*tickspsecond));
  1434.       calcrest=(calcrest%(60*tickspsecond));
  1435.       esec[j]=(calcrest/tickspsecond);
  1436.  
  1437.       cpu_use[j]=(unsigned int)pr->_uticks;      
  1438.       ustd[j]=cpu_use[j]/(3600*tickspsecond);
  1439.       calcrest=cpu_use[j]%(3600*tickspsecond);
  1440.       umin[j]=(calcrest/(60*tickspsecond));
  1441.       calcrest=(calcrest%(60*tickspsecond));
  1442.       usec[j]=(calcrest/tickspsecond);
  1443.  
  1444.       rxbytes[j]=(unsigned int)pr->_rbytes;
  1445.       txbytes[j]=(unsigned int)pr->_wbytes;
  1446.       ica[j]=(unsigned int)pr->_icalls;
  1447.       fca[j]=(unsigned int)pr->_fcalls;
  1448.       callnam[j]=(unsigned int) pr->_scall & 0xFF;
  1449.       signal[j]=(unsigned short)pr->_signal;
  1450.       cid[j]=(unsigned short)pr->_cid;
  1451.       ticks[0][j] = pr->_uticks+pr->_sticks;
  1452.  
  1453.       adress[j]=(modlink(names[j],0));
  1454.       if(adress[j]>0)
  1455.       {
  1456.           _cpymem(0, 60, adress[j], workbuff); 
  1457.           modaccess=(struct modulhead *) workbuff;
  1458.           modsize[j]=modaccess->modulsize;
  1459.           modown[j]=modaccess->modulowner;
  1460.           revision[j]=modaccess->moduledition;
  1461.           munlink(adress[j]);
  1462.       }
  1463.       j++;
  1464.     }
  1465.   }
  1466.  
  1467.   if(privileg && prillow)          /* set back priority to normal value   */
  1468.     setpr(ownuid,ownprior);
  1469.  
  1470.  
  1471.   if(!icpt_flag)                /* sleep a little bit ! */
  1472.   {
  1473.     if(start_flag)
  1474.         tsleep(delay*50);
  1475.     else
  1476.     {
  1477.         start_flag=TRUE;
  1478.         tsleep(40);
  1479.     }
  1480.   }
  1481.  
  1482.   if(privileg && prillow)            /* set priority to maximum ! */  
  1483.     setpr(ownuid,65535);
  1484.  
  1485.   imax = j-1;
  1486.   for(i=0;i<=imax;i++)
  1487.   {
  1488.     
  1489.     bytes = _get_process_desc(id[i],800, pr);
  1490.     if(bytes != -1)
  1491.     {
  1492.       modadr = (char *)pr->_pmodul;
  1493.       if(modadr!=0)
  1494.       {
  1495.           _cpymem(pr->_pid, 4, modadr+0xc, &nameadr); 
  1496.           nameadr += (int)modadr;
  1497.           _cpymem(pr->_pid, 16, nameadr, internames);
  1498.         internames[16]=0;
  1499.         strcpy(newnames,internames);
  1500.         uppercase(newnames);    
  1501.       }    
  1502.       else
  1503.         sprintf(newnames,"<NONE>");
  1504.  
  1505.       if((strcmp(newnames,names[i]))==0)
  1506.       {                                        /* process is still the same ! */
  1507.         ticks[1][i] = pr->_uticks+pr->_sticks;
  1508.       }
  1509.       else                                  /* process is not the same !   */
  1510.       {
  1511.         strcpy(names[i],newnames);           /* get the new name of process ! */
  1512.           id[i]=bytes;                        /* now get all information again */
  1513.           group[i]=pr->_group;
  1514.           user[i]=pr->_user;
  1515.           pid[i]=pr->_pid;
  1516.  
  1517.         getiopaths(pr,piopath[i]);
  1518.  
  1519.         if(id[i]==ownuid && privileg)
  1520.             prior[i]=ownprior;
  1521.         else
  1522.               prior[i]=pr->_prior;
  1523.   
  1524.           cpu_sys[i]=(unsigned int)pr->_sticks;
  1525.           estd[i]=cpu_sys[i]/(3600*tickspsecond);
  1526.           calcrest=cpu_sys[i]%(3600*tickspsecond);
  1527.           emin[i]=(calcrest/(60*tickspsecond));
  1528.           calcrest=(calcrest%(60*tickspsecond));
  1529.           esec[i]=(calcrest/tickspsecond);
  1530.  
  1531.           cpu_use[i]=(unsigned int)pr->_uticks;      
  1532.           ustd[i]=cpu_use[i]/(3600*tickspsecond);
  1533.           calcrest=cpu_use[i]%(3600*tickspsecond);
  1534.           umin[i]=(calcrest/(60*tickspsecond));
  1535.           calcrest=(calcrest%(60*tickspsecond));
  1536.           usec[i]=(calcrest/tickspsecond);
  1537.  
  1538.           rxbytes[i]=(unsigned int)pr->_rbytes;
  1539.           txbytes[i]=(unsigned int)pr->_wbytes;
  1540.           ica[i]=(unsigned int)pr->_icalls;
  1541.           fca[i]=(unsigned int)pr->_fcalls;
  1542.         callnam[i]=(unsigned int) pr->_scall & 0xFF;
  1543.           signal[i]=(unsigned short)pr->_signal;
  1544.           cid[i]=(unsigned short)pr->_cid;
  1545.           ticks[0][i]=pr->_uticks+pr->_sticks;
  1546.         ticks[1][i]=ticks[0][i];            /* there are no ticks elapsed ! */
  1547.         adress[i]=(modlink(names[i],0));
  1548.         if(adress[i]>0)                 /* the module is accessable   ! */
  1549.         {
  1550.             _cpymem(0, 60, adress[i], workbuff); 
  1551.            modaccess=(struct modulhead *) workbuff;
  1552.             modsize[i]=modaccess->modulsize;
  1553.             modown[i]=modaccess->modulowner;
  1554.             revision[i]=modaccess->moduledition;
  1555.             munlink(adress[i]);
  1556.           }
  1557.         maxprocent[i]=0;                    /* due to the process is new !  */    
  1558.       }
  1559.     }
  1560.     else
  1561.     {
  1562.       ticks[1][i]=ticks[0][i];
  1563.       maxprocent[i]=0;
  1564.       piopath[i][0]=0;    
  1565.       names[i][0]=0;    
  1566.     }
  1567.   }
  1568.   if(privileg && prillow)      /* setback the priority to normal values */  
  1569.     setpr(ownuid,ownprior);
  1570.  
  1571.   all_cpu=0;
  1572.   for(i=0;i<=imax;i++)
  1573.   {
  1574.     cpu_time[i]=((float)(ticks[1][i]-ticks[0][i]))
  1575.     /(float)(delay*50);
  1576.     all_cpu+=cpu_time[i];
  1577.   }
  1578.  
  1579.   act_task=0;
  1580.   for (i=0;i<=imax;i++)
  1581.   {
  1582.     if(all_cpu>0)
  1583.         cpu_proc[i] = (int)(cpu_time[i]*100/all_cpu);
  1584.     else
  1585.         cpu_proc[i]=0;
  1586.  
  1587.     if(cpu_proc[i]>0 && i>0)
  1588.         act_task++;
  1589.   }  
  1590. }
  1591. /*--------------------------------------------------------------------------*/
  1592. display_time()
  1593. {
  1594.   register struct sgtbuf timebuf,*t;
  1595.   register int frs_delay;
  1596.  
  1597.   t=&timebuf;
  1598.   getime(t);
  1599.   monat=t->t_month;
  1600.   tag=t->t_day;
  1601.   jahr=t->t_year;
  1602.   std=t->t_hour;
  1603.   min=t->t_minute;
  1604.   sec=t->t_second;
  1605.  
  1606. #ifdef DEMO  
  1607.   if(monat>DEMOMON || jahr>DEMOYEAR)
  1608.   {
  1609.     tmode(0,1);
  1610.     cursoron();
  1611.     effect();
  1612.     cls();
  1613.     printf("Demoversion time exeeded !\n");
  1614.     switch_ctrl(RESTORE);
  1615.     if(strncmp(portnam,"PKS",3)==0)
  1616.         sleep(2);
  1617.     exit(0);
  1618.   }    
  1619. #endif
  1620.   
  1621.   if(delay>3)
  1622.     frs_delay=2;
  1623.   else
  1624.     frs_delay=delay;
  1625.  
  1626.   if(min==16 && sec==7)
  1627.   {
  1628.     gotoxy(1,23);
  1629.     printf("\033[K\033[7;7m NOTE: \033[0;0m This program is dedicated to: Ruth S. Schmitt !\n");
  1630.     if(logindi)
  1631.         fprintf(lpp,"\033[K\033[7;7m NOTE: \033[0;0m This program is dedicated to: Ruth S. Schmitt !\n");
  1632.     sleep(5);
  1633.     gotoxy(1,23);
  1634.     printf("\033[K\n");
  1635.     if(logindi)
  1636.         fprintf(lpp,"\033[K\n");
  1637.     error_indi=TRUE;
  1638.   }
  1639.  
  1640.  
  1641.   if(start_flag && pwh && icpt_flag!=TRUE)
  1642.   { 
  1643.     if(unkown_flag==TRUE || 
  1644.     (min%PASSWORDPROOFTIME==0 && (sec>=0 && sec<=(frs_delay))))
  1645.     /* get the passwordfile again ! */
  1646.     {
  1647.         if(!susy_flag && !unkown_flag)
  1648.         {
  1649.             gotoxy(1,23);
  1650.                 printf("%s \n",proofpassstr);
  1651.             if(logindi)
  1652.                 fprintf(lpp,"%s \n",proofpassstr);
  1653.             sleep(2);
  1654.         }
  1655.  
  1656.         setuid(0);
  1657.         get_passworddate(1);
  1658.         if(filedate[0]!=filedate[1] || filestd[0]!=filestd[1])
  1659.         {
  1660.             if(!susy_flag)
  1661.             {
  1662.                 gotoxy(1,23);
  1663.                 printf("%s %02d-%02d-%02d  %02d:%02d \n",
  1664.                 passworddatestr,
  1665.                 lastpassworddate[0],
  1666.                 lastpassworddate[1],
  1667.                 lastpassworddate[2],
  1668.                 lastpassworddate[3],
  1669.                 lastpassworddate[4]);
  1670.                 if(logindi)
  1671.                     fprintf(lpp,"%s %02d-%02d-%02d  %02d:%02d \n",
  1672.                     passworddatestr,
  1673.                     lastpassworddate[0],
  1674.                     lastpassworddate[1],
  1675.                     lastpassworddate[2],
  1676.                     lastpassworddate[3],
  1677.                     lastpassworddate[4]);
  1678.  
  1679.                 sleep(3);
  1680.  
  1681.                 gotoxy(1,23);
  1682.                 printf("%s \n",readingmodipassstr);
  1683.                 if(logindi)
  1684.                     fprintf(lpp,"%s \n",readingmodipassstr);
  1685.             }
  1686.             pwh=get_password();
  1687.         }
  1688.         else                /* passwordfile is still the same ! */
  1689.        {
  1690.             if(unkown_flag) /* but unkown_flag was set before ! */
  1691.             {
  1692.                 if(!susy_flag)
  1693.                 {
  1694.                     gotoxy(1,23);
  1695.                     printf("%s \n",readingpassstr);
  1696.                     if(logindi)
  1697.                         fprintf(lpp,"%s \n",readingpassstr);
  1698.                 }
  1699.                 pwh=get_password();
  1700.             }
  1701.         }
  1702.  
  1703.  
  1704.         setuid(oldgrp*65536+oldus);
  1705.         if(!pwh)
  1706.         {
  1707.             name_flag=FALSE;
  1708.             gotoxy(1,23);
  1709.             printf("%s \n",readpasserrstr);
  1710.             if(logindi)
  1711.                 fprintf(lpp,"%s \n",readpasserrstr);
  1712.             refresh_flag=TRUE;
  1713.             sleep(2);
  1714.            }
  1715.         else
  1716.         {
  1717.             sleep(1);
  1718.             if(!susy_flag)
  1719.             {
  1720.                 gotoxy(1,23);
  1721.                 printf("\033[K\n");
  1722.                 if(logindi)
  1723.                     fprintf(lpp,"\033[K\n");
  1724.                 error_indi=TRUE;
  1725.             }
  1726.          }
  1727.         unkown_flag=TRISTATE; 
  1728.     }
  1729.   }
  1730.  
  1731.  
  1732.   if(min)                   /* minute !=0 ??? */
  1733.   {
  1734.     if((min%15)==0)         /* clear screen & unkown_flag all 15 minutes ! */
  1735.     {
  1736.         if(sec>=30 && sec<=(31+frs_delay))
  1737.         {
  1738.             if(refresh_flag==FALSE) /* only if there was no refresh before !*/    
  1739.                 refresh_flag=TRUE;
  1740.             unkown_flag=FALSE;
  1741.         }
  1742.     }
  1743.   }
  1744.   else                                                /* minute = 0 !    */
  1745.   {
  1746.     if(sec>=30 && sec<=(30+frs_delay) && refresh_flag==FALSE) /* clear display ! */
  1747.         refresh_flag=TRUE;
  1748.   }
  1749.  
  1750.  
  1751.   minage=_getsys(D_MinPty,2);
  1752.   maxage=_getsys(D_MaxAge,2);
  1753.  
  1754.   if(nodeflag)
  1755.   {
  1756.       if(nodenamlen<6)
  1757.           gotoxy(10,2);
  1758.       else    
  1759.           gotoxy(10+5-nodenamlen,2);
  1760.  
  1761.       printf("\033[7;7m  ");
  1762.       if(logindi)    
  1763.           fprintf(lpp,"\033[7;7m  ");
  1764.       if(oldprocs==imax)
  1765.       {    
  1766.           printf("%02d:%02d:%02d  %02d-%3s-19%02d  NODE: %s  TASKS: %03d  CPU: %d  \033[0;0m\n",
  1767.           std, min ,sec, tag, monate[monat-1], jahr,nodename,imax+1,processor);
  1768.         if(logindi)
  1769.               fprintf(lpp,"%02d:%02d:%02d  %02d-%3s-19%02d  NODE: %s  TASKS: %03d  CPU: %d  \033[0;0m\n",
  1770.               std, min ,sec, tag, monate[monat-1], jahr,nodename,imax+1,processor);
  1771.       }    
  1772.       else
  1773.       {
  1774.           printf("%02d:%02d:%02d  %02d-%3s-19%02d  NODE: %s  TASKS: \033[1;1m%03d\033[0;0m\033[7;7m  CPU: %d  \033[0;0m\n",
  1775.           std, min ,sec, tag, monate[monat-1], jahr,nodename,imax+1,processor);
  1776.         if(logindi)
  1777.               fprintf(lpp,"%02d:%02d:%02d  %02d-%3s-19%02d  NODE: %s  TASKS: \033[1;1m%03d\033[0;0m\033[7;7m  CPU: %d  \033[0;0m\n",
  1778.               std, min ,sec, tag, monate[monat-1], jahr,nodename,imax+1,processor);
  1779.       }
  1780.   }
  1781.   else
  1782.   {
  1783.       gotoxy(17,2);
  1784.       printf("\033[7;7m  ");
  1785.       if(logindi)    
  1786.           fprintf(lpp,"\033[7;7m  ");
  1787.       if(oldprocs==imax)
  1788.       {    
  1789.           printf("%02d:%02d:%02d  %02d-%3s-19%02d  TASKS: %03d  CPU: %d  \033[0;0m\n",
  1790.           std, min ,sec, tag, monate[monat-1], jahr,imax+1,processor);
  1791.         if(logindi)
  1792.               fprintf(lpp,"%02d:%02d:%02d  %02d-%3s-19%02d  TASKS: %03d  CPU: %d  \033[0;0m\n",
  1793.               std, min ,sec, tag, monate[monat-1], jahr,imax+1,processor);
  1794.       }
  1795.       else
  1796.       {
  1797.           printf("%02d:%02d:%02d  %02d-%3s-19%02d  TASKS: \033[1;1m%03d\033[0;0m\033[7;7m  CPU: %d  \033[0;0m\n",
  1798.           std, min ,sec, tag, monate[monat-1], jahr,imax+1,processor);
  1799.         if(logindi)
  1800.               fprintf(lpp,"%02d:%02d:%02d  %02d-%3s-19%02d  TASKS: \033[1;1m%03d\033[0;0m\033[7;7m  CPU: %d  \033[0;0m\n",
  1801.               std, min ,sec, tag, monate[monat-1], jahr,imax+1,processor);
  1802.       }
  1803.   }
  1804.   oldprocs=imax;  
  1805.   sprintf(displaystring,"Minage: ");
  1806.  
  1807.   if(minage==oldminage)
  1808.     sprintf(&displaystring[strlen(displaystring)],"%05d  ",minage);
  1809.   else
  1810.     sprintf(&displaystring[strlen(displaystring)],"\033[7;7m\033[1;1m%05d\033[0;0m  ",minage);
  1811.  
  1812.   sprintf(&displaystring[strlen(displaystring)],"Maxage: ");
  1813.   
  1814.   if(maxage==oldmaxage)
  1815.     sprintf(&displaystring[strlen(displaystring)],"%05d  ",maxage);
  1816.   else
  1817.     sprintf(&displaystring[strlen(displaystring)],"\033[7;7m\033[1;1m%05d\033[0;0m  ",maxage);
  1818.  
  1819.   sprintf(&displaystring[strlen(displaystring)],"ActiveTasks: ");
  1820.  
  1821.   if(act_task!=oldact_task)
  1822.     sprintf(&displaystring[strlen(displaystring)],"\033[7;7m\033[1;1m%03d\033[0;0m  ",act_task);
  1823.   else
  1824.     sprintf(&displaystring[strlen(displaystring)],"%03d  ",act_task);
  1825.  
  1826.   sprintf(&displaystring[strlen(displaystring)],"Delay: ");
  1827.  
  1828.   if(delay!=myolddelay)
  1829.     sprintf(&displaystring[strlen(displaystring)],"\033[7;7m\033[1;1m%02ds\033[0;0m  ",delay);
  1830.   else    
  1831.     sprintf(&displaystring[strlen(displaystring)],"%02ds  ",delay);
  1832.  
  1833.   if(porthandle!=-1)
  1834.   {
  1835.     gotoxy(5,3);
  1836.     sprintf(&displaystring[strlen(displaystring)],"Port: /%s \n",portnam);
  1837.   }
  1838.   else
  1839.   {
  1840.     gotoxy(8,3);
  1841.     sprintf(&displaystring[strlen(displaystring)],"\n");
  1842.   }
  1843.   printf(displaystring);
  1844.   if(logindi)
  1845.     fprintf(lpp,displaystring);
  1846.  
  1847.   oldminage=minage;
  1848.   oldmaxage=maxage;
  1849.   oldact_task=act_task;
  1850.   myolddelay=delay;
  1851. }
  1852. /*--------------------------------------------------------------------------*/
  1853. balken(n)
  1854. register int n;
  1855. {
  1856.   register int i,j=0;
  1857.   
  1858.   printf("\033(0");
  1859.   if(logindi)  
  1860.     fprintf(lpp,"\033(0");
  1861.   for(i=1;i<=(n/2.5);i++)
  1862.   {
  1863.     printf("a");
  1864.     if(logindi)
  1865.         fprintf(lpp,"a");
  1866.     j++;
  1867.   }   
  1868.   printf("\033(B");
  1869.   if(logindi)  
  1870.     fprintf(lpp,"\033(B");
  1871.  
  1872.   if(n==100)
  1873.     return(0);  
  1874.  
  1875.    for(i=j+1;i<=40;i++)
  1876.    {
  1877.     if(i%10==0 && i!=40)
  1878.     {
  1879.         printf("\033(0x\033(B");
  1880.         if(logindi)
  1881.             fprintf(lpp,"\033(0x\033(B");
  1882.     } 
  1883.     else
  1884.     {
  1885.         printf(" ");
  1886.         if(logindi)
  1887.             fprintf(lpp," ");
  1888.     }
  1889.    }
  1890. }
  1891. /*--------------------------------------------------------------------------*/
  1892. display_procs()
  1893. {
  1894.   register int i,kj,count=0, im;
  1895.   int pmax=0,killus;
  1896.  
  1897.   for(i=0;i<=imax;i++)
  1898.   {
  1899.     if(icpt_flag)
  1900.     {
  1901.       fflush(stdout);    
  1902.       if(logindi)
  1903.           fflush(lpp);    
  1904.       return(0);
  1905.     }
  1906.  
  1907.     if(cpu_proc[i]>0)
  1908.     {
  1909.       gotoxy(0,6+count);
  1910.       printf("%03d",id[i]);
  1911.       if(logindi)
  1912.           fprintf(lpp,"%03d",id[i]);
  1913.  
  1914.       gotoxy(5,6+count);
  1915.  
  1916.       if(pwh && name_flag)
  1917.       {
  1918.           killus=disp_user(i);
  1919.         if(!killus && watchy_flag)
  1920.         {
  1921.             if(!mark_proc)
  1922.                 mark_proc=id[i];
  1923.             else
  1924.                 killit=TRUE;
  1925.         }
  1926.       }
  1927.       else
  1928.       {
  1929.           if(prior_flag)
  1930.           {
  1931.             if(prior[i]<=128)
  1932.             {
  1933.                 printf("%5d",prior[i]);
  1934.                 if(logindi)
  1935.                     fprintf(lpp,"%5d",prior[i]);
  1936.             }
  1937.             else
  1938.             {
  1939.                 printf("\033[7;7m%5d\033[0;0m",prior[i]);
  1940.                 if(logindi)
  1941.                     fprintf(lpp,"\033[7;7m%5d\033[0;0m",prior[i]);
  1942.             }
  1943.           }
  1944.           else
  1945.         {
  1946.             printf("%01d.%01d  ",group[i],user[i]);
  1947.             if(logindi)
  1948.                 fprintf(lpp,"%01d.%01d  ",group[i],user[i]);
  1949.         }
  1950.       }
  1951.  
  1952.       gotoxy(16,6+count); /* x was 12 */
  1953.       if(i!=0)
  1954.       {
  1955.               printf("%-15s ",names[i]);
  1956.             if(logindi)
  1957.                    fprintf(lpp,"%-15s ",names[i]);
  1958.       }
  1959.       else
  1960.       {
  1961.             printf("CPU IDLE        ");
  1962.             if(logindi)
  1963.                 fprintf(lpp,"CPU IDLE        ");
  1964.       }
  1965.  
  1966.       gotoxy(31,6+count);
  1967.       if(maxh_flag && i!=0)
  1968.       {
  1969.             if(maxprocent[i]<=cpu_proc[i])
  1970.                 maxprocent[i]=cpu_proc[i];
  1971.             printf("\033[7;7m\033[1;1m%3d %%\033[0;0m",maxprocent[i]);
  1972.             if(logindi)
  1973.                 fprintf(lpp,"\033[7;7m\033[1;1m%3d %%\033[0;0m",maxprocent[i]);
  1974.       }
  1975.       else
  1976.       {    
  1977.           if(mark && cpu_proc[i]>=75 && i!=0)
  1978.         {
  1979.             printf("\033[7;7m%3d %%\033[0;0m",cpu_proc[i]);
  1980.             if(logindi)
  1981.                 fprintf(lpp,"\033[7;7m%3d %%\033[0;0m",cpu_proc[i]);
  1982.         }
  1983.           else
  1984.         {
  1985.             printf("%3d %%",cpu_proc[i]);
  1986.             if(logindi)
  1987.                 fprintf(lpp,"%3d %%",cpu_proc[i]);
  1988.         }
  1989.       }
  1990.       gotoxy(38,6+count);
  1991.       balken(cpu_proc[i]);
  1992.       count++;
  1993.  
  1994.       if(count==16 && imax>=count)  /* next screen ! */
  1995.       {
  1996.         printf("\n");
  1997.         if(logindi)
  1998.             fprintf(lpp,"\n");
  1999.         if(!icpt_flag)
  2000.             sleep(2);
  2001.         clear_rest(count);
  2002.         if(icpt_flag)
  2003.         {
  2004.           fflush(stdout);
  2005.           if(logindi)
  2006.             fflush(lpp);
  2007.           return(0);
  2008.         }    
  2009.         count=0;
  2010.       }
  2011.     }
  2012.   }
  2013.   clear_rest(count);
  2014. }
  2015. /*--------------------------------------------------------------------------*/
  2016. char *syscname(n)
  2017. register int n;
  2018. {
  2019.    if(n >= 128 && (n-128 < (sizeof(osiotble) / sizeof(char*))))
  2020.       return osiotble[n-128];
  2021.    else if(n >= 0 && n < (sizeof(ossvtble) / sizeof(char*)))
  2022.          return ossvtble[n];
  2023.    else return badcode;
  2024. }
  2025. /*--------------------------------------------------------------------------*/
  2026. check_login()
  2027. {
  2028.     register int i, login_c=0;
  2029.  
  2030.     for(i=0;i<=imax;i++)
  2031.     {
  2032.         if(strncmp("LOGIN",names[i],5)==0)
  2033.         {
  2034.             gotoxy(1,23);
  2035.             printf("\033[7;7m\033[1;1m SYSMON-INFO: \033[0;0m Process: %d  '%s' %s in progress !\033[K\n",
  2036.             id[i],names[i],piopath[i]);
  2037.             if(logindi)
  2038.             {
  2039.                 fprintf(lpp,"\033[7;7m\033[1;1m SYSMON-INFO: \033[0;0m Process: %d  '%s' %s in progress !\033[K\n",
  2040.                 id[i],names[i],piopath[i]);
  2041.             }
  2042.             login_c++;
  2043.             sleep(1);
  2044.         }
  2045.     }
  2046.     return(login_c);
  2047. }
  2048. /*--------------------------------------------------------------------------*/
  2049. display_data()
  2050. {
  2051.   register int i,kj,count=0, im;
  2052.   int pmax=0,killus;
  2053.  
  2054.   if(old_imax!=imax)
  2055.   {
  2056.     under_title();
  2057.     old_imax=imax;      
  2058.   }    
  2059.  
  2060.   if(clflg)
  2061.   for(i=1;i<=15;i++)
  2062.   {
  2063.     gotoxy(77,6+i);
  2064.     printf("\033[K\n");
  2065.     if(logindi)
  2066.         fprintf(lpp,"\033[K\n");
  2067.   }
  2068.  
  2069.  
  2070.   for(i=actualcount;i<=actualcount+15;i++)
  2071.   {
  2072.     if(icpt_flag)
  2073.     {
  2074.         clear_restdata(count);    
  2075.         fflush(stdout);
  2076.         if(logindi)
  2077.             fflush(lpp);
  2078.           return(0);
  2079.     }
  2080.  
  2081.     if(i>imax)
  2082.       break;
  2083.  
  2084.     if(susy_flag && startc==count)
  2085.     {
  2086.         gotoxy(0,6+count);
  2087.         printf("\033[1;1m\033[7;7m");
  2088.         if(logindi)
  2089.             fprintf(lpp,"\033[1;1m\033[7;7m");
  2090.         markpr=id[i];
  2091.         markprior=prior[i];
  2092.         strcpy(killnam,names[i]);
  2093.     }
  2094.  
  2095.     if(!active_flag || user[i]!=0 || i==0) /* display user tasks */
  2096.     {
  2097.       gotoxy(0,6+count);  /* display id       */
  2098.       printf("%03d ",id[i]);
  2099.       if(logindi)    
  2100.           fprintf(lpp,"%03d ",id[i]);
  2101.       gotoxy(5,6+count);  /* display pid      */
  2102.       printf("%03d  ",pid[i]);
  2103.       if(logindi)    
  2104.           fprintf(lpp,"%03d  ",pid[i]);
  2105.       gotoxy(10,6+count);
  2106.  
  2107.       if(pwh && name_flag)
  2108.       {
  2109.         killus=disp_user(i);
  2110.         if(!killus && watchy_flag)
  2111.         {
  2112.             if(!mark_proc)
  2113.                 mark_proc=id[i];
  2114.             else
  2115.                 killit=TRUE;
  2116.         }
  2117.       }
  2118.       else
  2119.       {    
  2120.         if(prior[i]<=128 || !i || (susy_flag && startc==count)) /* display prior    */
  2121.         {
  2122.             printf("%5d  ",prior[i]);
  2123.             if(logindi)
  2124.                 fprintf(lpp,"%5d  ",prior[i]);
  2125.         }
  2126.           else
  2127.         {
  2128.             printf("\033[7;7m%5d\033[0;0m  ",prior[i]);
  2129.             if(logindi)
  2130.                 fprintf(lpp,"\033[7;7m%5d\033[0;0m  ",prior[i]);
  2131.         }
  2132.           gotoxy(17,6+count);
  2133.           printf("%01d.%01d  ",group[i],user[i]);
  2134.         if(logindi)
  2135.               fprintf(lpp,"%01d.%01d  ",group[i],user[i]);
  2136.       }
  2137.       fflush(stdout);
  2138.       gotoxy(22,6+count);
  2139.       if(i!=0)
  2140.       {
  2141.              printf("%-15s ",names[i]);
  2142.             if(logindi)
  2143.                   fprintf(lpp,"%-15s ",names[i]);
  2144.       }
  2145.       else
  2146.       {
  2147.         if(exmode==2)
  2148.         {
  2149.               printf("%-15s ",names[i]);
  2150.             if(logindi)
  2151.                   fprintf(lpp,"%-15s ",names[i]);
  2152.         }    
  2153.         else
  2154.         {    
  2155.               printf("CPU IDLE        ");
  2156.             if(logindi)
  2157.                   fprintf(lpp,"CPU IDLE        ");
  2158.         }
  2159.       }
  2160.       gotoxy(38,6+count);
  2161.       switch(exmode)
  2162.       {
  2163.         case 0:
  2164.             if(rxbytes[i]<1000000 && txbytes[i]<1000000)
  2165.             {
  2166.                  printf("%8d %8d ",rxbytes[i],txbytes[i]);
  2167.                     if(logindi)
  2168.                      fprintf(lpp,"%8d %8d ",rxbytes[i],txbytes[i]);
  2169.             }
  2170.             else
  2171.             {
  2172.                 if(rxbytes[i]>1000000000 || txbytes[i]>1000000000)
  2173.                 {
  2174.                     printf("%6dMB %6dMB ",(rxbytes[i]/1024000),(txbytes[i]/1024000));
  2175.                     if(logindi)
  2176.                         fprintf(lpp,"%6dMB %6dMB ",(rxbytes[i]/1024000),(txbytes[i]/1024000));
  2177.                 }
  2178.                 else
  2179.                 {
  2180.                     printf("%6dkb %6dkb ",(rxbytes[i]/1024),(txbytes[i]/1024));
  2181.                     if(logindi)
  2182.                         fprintf(lpp,"%6dkb %6dkb ",(rxbytes[i]/1024),(txbytes[i]/1024));
  2183.                 }
  2184.             }
  2185.             break;
  2186.         case 1:
  2187.             if(ica[i]<10000000)
  2188.             {
  2189.                   printf("%8d ",ica[i]);
  2190.                 if(logindi)
  2191.                       fprintf(lpp,"%8d ",ica[i]);
  2192.             }
  2193.             else
  2194.             {
  2195.                   printf("%7dK ",(ica[i]/1000));
  2196.                 if(logindi)
  2197.                       fprintf(lpp,"%7dK ",(ica[i]/1000));
  2198.             }
  2199.  
  2200.             if(fca[i]<10000000)
  2201.             {
  2202.                 printf("%8d ",fca[i]);
  2203.                 if(logindi)
  2204.                       fprintf(lpp,"%8d ",fca[i]);
  2205.             }
  2206.             else
  2207.             {
  2208.                 printf("%7dK ",(fca[i]/1000));
  2209.                 if(logindi)
  2210.                       fprintf(lpp,"%7dK ",(fca[i]/1000));
  2211.             }
  2212.             break;
  2213.         case 2:
  2214.             if(adress[i]>0)
  2215.             {
  2216.                   printf("%8x   %6d  ",adress[i],modsize[i]);
  2217.                 if(logindi)
  2218.                       fprintf(lpp,"%8x   %6d  ",adress[i],modsize[i]);
  2219.             }
  2220.             else
  2221.             {
  2222.                   printf("--------   ------  ");
  2223.                 if(logindi)
  2224.                       fprintf(lpp,"--------   ------  ");
  2225.             }
  2226.             break;
  2227.         case 3:
  2228.                 printf("%-40s",piopath[i]);
  2229.                 if(logindi)
  2230.                       fprintf(lpp,"%-40s",piopath[i]);
  2231.             break;
  2232.       }
  2233.       fflush(stdout);
  2234.     
  2235.       switch(exmode)
  2236.       {
  2237.         case 0:
  2238.             gotoxy(56,6+count);
  2239.               printf("%3d:%02d:%02d  ",estd[i],emin[i],esec[i]);
  2240.             if(logindi)
  2241.                   fprintf(lpp,"%3d:%02d:%02d  ",estd[i],emin[i],esec[i]);
  2242.               gotoxy(67,6+count);
  2243.               printf("%3d:%02d:%02d ",ustd[i],umin[i],usec[i]);
  2244.             if(logindi)
  2245.                   fprintf(lpp,"%3d:%02d:%02d ",ustd[i],umin[i],usec[i]);
  2246.             break;
  2247.         case 1:
  2248.             gotoxy(56,6+count);
  2249.               printf("%-7s ",syscname(callnam[i]));
  2250.             if(logindi)
  2251.                   fprintf(lpp,"%-7s ",syscname(callnam[i]));
  2252.             gotoxy(64,6+count);
  2253.               printf("%5d  ",signal[i]);
  2254.             if(logindi)
  2255.                   fprintf(lpp,"%5d  ",signal[i]);
  2256.               gotoxy(71,6+count);
  2257.               printf("%5d ",cid[i]);
  2258.             if(logindi)
  2259.                   fprintf(lpp,"%5d ",cid[i]);
  2260.               break;
  2261.         case 2:
  2262.             if(adress[i]>0)
  2263.             {
  2264.                 gotoxy(57,6+count);
  2265.                   printf("%5d      ",revision[i]);
  2266.                 if(logindi)
  2267.                       fprintf(lpp,"%5d      ",revision[i]);
  2268.                   gotoxy(68,6+count);
  2269.                   printf(" %d.%d     ",
  2270.                 ((modown[i] & 0xffff0000)>>16),
  2271.                 (modown[i] & 0x0000ffff));
  2272.                 if(logindi)
  2273.                       fprintf(lpp," %d.%d     ",
  2274.                     ((modown[i] & 0xffff0000)>>16),
  2275.                     (modown[i] & 0x0000ffff));
  2276.             }
  2277.             else
  2278.             {
  2279.                 gotoxy(57,6+count);
  2280.                   printf("-----      ");
  2281.                 if(logindi)
  2282.                       fprintf(lpp,"-----      ");
  2283.                   gotoxy(68,6+count);
  2284.                   printf("--.--     ");
  2285.                 if(logindi)
  2286.                       fprintf(lpp,"--.--     ");
  2287.             }
  2288.             break;
  2289.       }
  2290.       fflush(stdout);
  2291.       gotoxy(77,6+count);
  2292.  
  2293.       if(cpu_proc[i]>0)
  2294.       {
  2295.         if(maxh_flag && i!=0)
  2296.         {
  2297.             if(maxprocent[i]<=cpu_proc[i])
  2298.                 maxprocent[i]=cpu_proc[i];
  2299.             printf("\033[7;7m\033[1;1m%3d%%\033[0;0m\n",maxprocent[i]);
  2300.             if(logindi)
  2301.                 fprintf(lpp,"\033[7;7m\033[1;1m%3d%%\033[0;0m\n",maxprocent[i]);
  2302.         }    
  2303.         else    
  2304.         {
  2305.             printf("\033[7;7m%3d%%\033[0;0m\n",cpu_proc[i]);
  2306.             if(logindi)
  2307.                 fprintf(lpp,"\033[7;7m%3d%%\033[0;0m\n",cpu_proc[i]);
  2308.         }
  2309.       }
  2310.       else
  2311.       {
  2312.         if(susy_flag)
  2313.         {
  2314.             if(prior[i]==0 && minage==1)
  2315.             {
  2316.                 printf("\033[0;0m  *  \n");
  2317.                 if(logindi)
  2318.                     fprintf(lpp,"\033[0;0m  *  \n");
  2319.             }
  2320.             else
  2321.             {
  2322.                 printf("\033[0;0m     \n");
  2323.                 if(logindi)
  2324.                     fprintf(lpp,"\033[0;0m     \n");
  2325.             }
  2326.         }
  2327.         else
  2328.         {
  2329.             if(prior[i]==0 && minage==1)
  2330.             {
  2331.                 printf("  *  \n");
  2332.                 if(logindi)
  2333.                 fprintf(lpp,"  *  \n");
  2334.             }
  2335.             else
  2336.             {
  2337.                 printf("     \n");
  2338.                 if(logindi)
  2339.                     fprintf(lpp,"     \n");
  2340.             }
  2341.         }
  2342.       }
  2343.       fflush(stdout);        
  2344.       count++;
  2345.       
  2346.     }  /* end of active tasks !   */
  2347.  }
  2348.  clear_restdata(count);
  2349. }
  2350. /*----------------------------------------------------------------------*/
  2351. clear_restdata(ui)
  2352. register int ui;
  2353. {
  2354.   register int kj;
  2355.  
  2356.   for(kj=ui;kj<lastcount;kj++)
  2357.   {
  2358.     if(icpt_flag)
  2359.     {
  2360.       fflush(stdout);
  2361.       if(logindi)    
  2362.           fflush(lpp);
  2363.       return(0);
  2364.     }
  2365.     gotoxy(0,6+kj);
  2366.     printf("\033[K\n");
  2367.     if(logindi)
  2368.         fprintf(lpp,"\033[K\n");
  2369.   }
  2370.   lastcount=ui;
  2371. }
  2372. /*---------------------------------------------------------------------------*/
  2373. clear_rest(ui)
  2374. register int ui;
  2375. {
  2376.   register int kj;
  2377.  
  2378.   for(kj=ui;kj<lastcount;kj++)
  2379.   {
  2380.     if(icpt_flag)
  2381.     {
  2382.       fflush(stdout);
  2383.       if(logindi)
  2384.           fflush(lpp);
  2385.       return(0);
  2386.     }
  2387.     gotoxy(0,6+kj);
  2388.     printf("   ");
  2389.     if(logindi)
  2390.         fprintf(lpp,"   ");
  2391.     gotoxy(5,6+kj);
  2392.     if(pwh && name_flag)
  2393.     {
  2394.         printf("            ");
  2395.         if(logindi)
  2396.             fprintf(lpp,"            ");
  2397.     }
  2398.     else
  2399.     {
  2400.         printf("     ");
  2401.         if(logindi)
  2402.             fprintf(lpp,"     ");
  2403.     }
  2404.     gotoxy(16,6+kj);    /* x was 12 */
  2405.     printf("                ");
  2406.     if(logindi)
  2407.         fprintf(lpp,"                ");
  2408.     gotoxy(31,6+kj);
  2409.     printf("     ");
  2410.     if(logindi)
  2411.         fprintf(lpp,"     ");
  2412.     gotoxy(38,6+kj);
  2413.  
  2414.     printf(
  2415.     "         \033(0x\033(B         \033(0x\033(B         \033(0x\033(B          \n");
  2416.     if(logindi)
  2417.         fprintf(lpp,
  2418.     "         \033(0x\033(B         \033(0x\033(B         \033(0x\033(B          \n");
  2419.   }
  2420.   gotoxy(1,22);
  2421.   printf("\n");
  2422.   if(logindi)  
  2423.     fprintf(lpp,"\n");
  2424.   lastcount=ui;
  2425. }
  2426. /*------------------------------------------------------------------------*/
  2427. serial_error(seri_err)
  2428. int seri_err;
  2429. {
  2430.     gotoxy(1,23);
  2431.     printf("\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON-FATAL-ERROR: \033[0;0m Keyboard-Read failed !  errno=%d\n"
  2432.     ,seri_err);
  2433.     if(logindi)
  2434.         fprintf(lpp,"\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON-FATAL-ERROR: \033[0;0m Keyboard-Read failed !  errno=%d\n",
  2435.         seri_err);
  2436.     gotoxy(1,23);
  2437.     cursoron();
  2438.     tmode(0,1);
  2439.     if(logindi)
  2440.         fclose(lpp);
  2441.     switch_ctrl(RESTORE);
  2442.     if(strncmp(portnam,"PKS",3)==0)
  2443.         sleep(2);
  2444.     exit(0);
  2445. }
  2446. /*------------------------------------------------------------------------*/
  2447. clean_input()
  2448. {
  2449.     register int j, rbytes;
  2450.     char dumio[255];
  2451.  
  2452.     for(j=0;j<=10;j++)
  2453.     {
  2454.         rbytes=_gs_rdy(0);
  2455.         if(rbytes>0)
  2456.         {
  2457.             rbytes=read(0,dumio,rbytes); /* read the bytes !*/
  2458.             j=0;
  2459.         }
  2460.         else
  2461.             tsleep(5);
  2462.     }
  2463. }
  2464. /*------------------------------------------------------------------------*/
  2465. display()
  2466. {  
  2467.   register int bytes=0, rbytes=0, ptaste, i;
  2468.   int kha, inkh=0,prh, forkh,retstr=FALSE, j=0;
  2469.   int setprhand, newprior, delta=1, momage;
  2470.   int fid;
  2471.   char io_buff[255], inkstr[100], ptastbuff[100], clearcondi=2;
  2472.   char ushell[100];  
  2473.   char *sshell;
  2474.   char dc=0;
  2475.   char selecta=FALSE;
  2476.   char suicid_flag=FALSE;
  2477.  
  2478.  
  2479.  
  2480.   if(!mode_flag)
  2481.     display_frame();
  2482.   else
  2483.     display_dframe();
  2484.  
  2485.   if(!nodeflag)
  2486.   {
  2487.     gotoxy(1,23);
  2488.     printf(
  2489.     "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m Can't open '%s' [Node-definition file] \n",nodedefnam);
  2490.     if(logindi)
  2491.         fprintf(lpp,
  2492.     "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m Can't open '%s' [Node-definition file] \n",nodedefnam);
  2493.     error_indi=TRUE;
  2494.   }
  2495.  
  2496.   get_ticktime();               /* how long is a tick lasting ? */
  2497.   get_cputime();
  2498.   _ss_ssig(0,DATAPRESENT);      /* send  signal on data ready */
  2499.  
  2500.   for(;;)                 /* endless loop ! */
  2501.   {
  2502.     if(icpt_flag==FALSE)  /* icpt_flag=0 */
  2503.     {
  2504.         get_cputime();
  2505.  
  2506.         if(mode_flag && actualcount>=16 && 
  2507.         (imax+1-actualcount)==0)                     /* if last shown process */
  2508.         {                                            /* died, one page back ! */
  2509.             error_indi=FALSE;
  2510.             actualcount-=16;
  2511.             under_title();
  2512.             scc=fa+fb;
  2513.             startc=15;
  2514.         }
  2515.     }
  2516.     else        /* icpt_flag=TRUE */
  2517.     {
  2518.         fflush(stdout);
  2519.         i=0;
  2520.         ret_disp=0;
  2521.  
  2522.         for(;;)
  2523.         {
  2524.             bytes=_gs_rdy(0);
  2525.             if(bytes>0)            /* DATA PRESENT ON KYBD */
  2526.             {   
  2527.                 memset(&io_buff[0],0,sizeof(io_buff));  /* clear sign buffer */
  2528.                 
  2529.                 if(bytes>9)        /* BUFFER FULL ! */
  2530.                 {                   /* maximal 9 normal commands or 3 cursor */
  2531.                     gotoxy(1,23);   /* moves allowed ! */
  2532.                     clean_input(); /* empty pending inputbytes ! */
  2533.                     io_buff[0]='~';
  2534.                     break;
  2535.                 }
  2536.                 else
  2537.                     rbytes=read(0,io_buff,1);    /* read exactly one byte ! */
  2538.                 if(rbytes==-1)
  2539.                     serial_error(errno);
  2540.  
  2541.                 if(io_buff[0]!=ESC)    /* normal command ! */
  2542.                 {
  2543.                     io_buff[0]=toupper(io_buff[0]);
  2544.                     break;
  2545.                 }
  2546.                 else                /* ESC was detected !  */
  2547.                 {
  2548.                     for(j=0;j<=10;j++)
  2549.                     {
  2550.                         rbytes=_gs_rdy(0);
  2551.                         if(rbytes>=2)
  2552.                         {
  2553.                             j=0;
  2554.                             break;
  2555.                         }
  2556.                         else
  2557.                             tsleep(2);
  2558.                     }
  2559.  
  2560.                     if(rbytes>=2 && j==0)
  2561.                     {
  2562.                         rbytes=read(0,&io_buff[1],2);   /* read 2 more bytes !*/
  2563.                         if(rbytes==2)
  2564.                         {
  2565.                             if(io_buff[1]=='[')        /* ESC sequence detected !*/
  2566.                             {
  2567.                                 switch(io_buff[2])
  2568.                                 {
  2569.                                        case 'A':         /* CURSOR UP ! */
  2570.                                            io_buff[0]='<';
  2571.                                            break;
  2572.                                     case 'B':         /* CURSOR DOWN ! */
  2573.                                            io_buff[0]='>';
  2574.                                            break;
  2575.                                     case 'C':          /* CURSOR RIGHT ! */
  2576.                                            io_buff[0]='+';
  2577.                                            break;
  2578.                                     case 'D':        /* CURSOR LEFT ! */
  2579.                                            io_buff[0]='-';
  2580.                                            break;
  2581.                                     default:
  2582.                                         gotoxy(1,23);
  2583.                                         printf("%s\n",undefkeystr);
  2584.                                         if(logindi)
  2585.                                             fprintf(lpp,"%s\n",undefkeystr);
  2586.                                            io_buff[0]='~';
  2587.                                         error_indi=TRUE;
  2588.                                         break;
  2589.                                 }
  2590.                                 break;
  2591.                             }
  2592.                             else
  2593.                             {
  2594.                                 gotoxy(1,23);
  2595.                                 printf("%s\n",undefkeystr);
  2596.                                 if(logindi)
  2597.                                     fprintf(lpp,"%s\n",undefkeystr);
  2598.                                    io_buff[0]='~';
  2599.                                 error_indi=TRUE;
  2600.                                 break;
  2601.                             }
  2602.                         }
  2603.                         else
  2604.                             serial_error(errno);
  2605.                     }
  2606.                     else
  2607.                     {
  2608.                         gotoxy(1,23);
  2609.                         printf("%s\n",undefkeystr);
  2610.                         if(logindi)
  2611.                            fprintf(lpp,"%s\n",undefkeystr);
  2612.                         clean_input();
  2613.                         error_indi=TRUE;
  2614.                           io_buff[0]='~';
  2615.                         break;
  2616.                     }
  2617.                 }
  2618.             }
  2619.             else    /* no data present ! */
  2620.             {
  2621.                 if(i>=50)
  2622.                 {
  2623.                        gotoxy(1,23);
  2624.                     printf(
  2625.                      "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON-ERROR \033[0;0m SERIAL-DEVICE not ready ! errno=%d \n",errno);
  2626.                     if(logindi)
  2627.                         fprintf(lpp,
  2628.                          "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON-ERROR \033[0;0m SERIAL-DEVICE not ready ! errno=%d \n",errno);
  2629.                     gotoxy(1,23);
  2630.                     cursoron();
  2631.                     tmode(0,1);
  2632.                     if(logindi)
  2633.                         fclose(lpp);
  2634.                     switch_ctrl(RESTORE);
  2635.                     if(strncmp(portnam,"PKS",3)==0)
  2636.                         sleep(2);
  2637.                     exit(0);
  2638.                 }
  2639.                 tsleep(2);
  2640.                 i++;
  2641.             }
  2642.         }
  2643.  
  2644.  
  2645.         if(killer || spr_flag)
  2646.         {
  2647.             bell=OFF;
  2648.             if(killer)
  2649.             {
  2650.                 if(io_buff[0]=='Y')
  2651.                  {
  2652.                     if(suicid_flag==TRUE)
  2653.                     {
  2654.                      gotoxy(1,23);
  2655.                         printf("%s\n",jokestr);
  2656.                         if(logindi)
  2657.                             fprintf(lpp,"%s\n",jokestr);
  2658.                         suicid_flag=FALSE;
  2659.                          error_indi=TRUE;
  2660.                     }
  2661.                     else
  2662.                     {
  2663.                      gotoxy(1,23);
  2664.                         fflush(stdout);
  2665.                         tsleep(20);
  2666.                          kha=kill_pr(markpr);
  2667.                          if(kha==0)
  2668.                          {
  2669.                         sleep(1);
  2670.                              gotoxy(1,23);
  2671.                             printf("\033[K\007\033[7;7m\033[5;5m SYSMON: \033[0;0m Process: %d  '%s' has been killed !\n"
  2672.                              ,markpr,killnam);
  2673.                             if(logindi)
  2674.                                 fprintf(lpp,
  2675.                                  "\033[K\007\033[7;7m\033[5;5m SYSMON: \033[0;0m Process: %d  '%s' has been killed !\n"
  2676.                                  ,markpr,killnam);
  2677.                             sleep(1);
  2678.                              error_indi=TRISTATE;
  2679.                             get_cputime();
  2680.  
  2681.                             if(scc>fa+1)
  2682.                             {
  2683.                                 scc--;
  2684.                                 startc--;
  2685.                             }
  2686.                             else
  2687.                             {
  2688.                                 if(actualcount>=16)
  2689.                                 {
  2690.                                     actualcount-=16;
  2691.                                     under_title();
  2692.                                     scc--;
  2693.                                     startc=15;
  2694.                                 }
  2695.                                 else
  2696.                                     actualcount=0;
  2697.                             }
  2698.                          }
  2699.                          else
  2700.                         {
  2701.                             gotoxy(1,23);
  2702.                              printf(
  2703.                              "\033[K\007\033[7;7m\033[5;5m SYSMON ERROR: \033[0;0m Process: '%s' ID: %d can't be killed ! errno=%d \n"
  2704.                              ,killnam,markpr,kha);
  2705.                             if(logindi)                
  2706.                                  fprintf(lpp,
  2707.                                  "\033[K\007\033[7;7m\033[5;5m SYSMON ERROR: \033[0;0m Process: '%s' ID: %d can't be killed ! errno=%d \n"
  2708.                                  ,killnam,markpr,kha);
  2709.                          error_indi=TRUE;
  2710.                          }
  2711.                      }   /* end of suicid */
  2712.                  }
  2713.                  else
  2714.                  {
  2715.                      gotoxy(1,23);
  2716.                     printf(
  2717.                      "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m Operation canceled. Process: %d  '%s' not killed !\n"
  2718.                      ,markpr,killnam);
  2719.                     if(logindi)
  2720.                         fprintf(lpp,
  2721.                          "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m Operation canceled. Process: %d  '%s' not killed !\n"
  2722.                          ,markpr,killnam);
  2723.                     error_indi=TRUE;
  2724.                     suicid_flag=FALSE;
  2725.                  }
  2726.                  killer=FALSE;
  2727.             }    /* end of killer if */
  2728.  
  2729.             if(spr_flag==TRUE)
  2730.             {
  2731.              if(io_buff[0]=='Y')
  2732.              {
  2733.                  kha=setpr(markpr,newprior);
  2734.                  if(kha!=-1)
  2735.                  {
  2736.                     if(ownuid==markpr)
  2737.                         ownprior=newprior;
  2738.                      gotoxy(1,23);
  2739.                     printf(
  2740.                      "\033[K\007\033[7;7m\033[5;5m SYSMON: \033[0;0m Priority of process: %d  '%s' has been modified !\n"
  2741.                      ,markpr,killnam);
  2742.                     if(logindi)
  2743.                         fprintf(lpp,
  2744.                          "\033[K\007\033[7;7m\033[5;5m SYSMON: \033[0;0m Priority of process: %d  '%s' has been modified !\n"
  2745.                          ,markpr,killnam);
  2746.                     get_cputime();
  2747.                      error_indi=TRUE;
  2748.                     ret_disp=100;
  2749.                  }
  2750.                  else
  2751.                 {
  2752.                     gotoxy(1,23);
  2753.                      printf(
  2754.                      "\033[K\007\033[7;7m\033[5;5m SYSMON ERROR: \033[0;0m Priority of process: '%s' ID: %d can't be modified ! errno=%d \n"
  2755.                      ,killnam,markpr,kha);
  2756.                  error_indi=TRUE;
  2757.                     if(logindi)
  2758.                          fprintf(lpp,
  2759.                          "\033[K\007\033[7;7m\033[5;5m SYSMON ERROR: \033[0;0m Priority of process: '%s' ID: %d can't be modified ! errno=%d \n"
  2760.                          ,killnam,markpr,kha);
  2761.                  }
  2762.              }
  2763.              else
  2764.              {
  2765.                  gotoxy(1,23);
  2766.                 printf(
  2767.                  "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m Operation canceled. Priority of process: '%s' not modified !\n"
  2768.                  ,killnam);
  2769.                 if(logindi)
  2770.                     fprintf(lpp,
  2771.                      "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m Operation canceled. Priority of process: '%s' not modified !\n"
  2772.                      ,killnam);
  2773.                 error_indi=TRUE;
  2774.              }
  2775.              spr_flag=FALSE;
  2776.             }
  2777.  
  2778.             if(spr_flag==SUSPEND)
  2779.             {
  2780.                 if(io_buff[0]=='Y')
  2781.                  {
  2782.                     if(markprior>0)               /* the process is not suspended yet ! */
  2783.                     {
  2784.                         if(suicid_flag==TRUE)
  2785.                         {
  2786.                          gotoxy(1,23);
  2787.                             printf("%s\n",jokestr);
  2788.                             if(logindi)
  2789.                                 fprintf(lpp,"%s\n",jokestr);
  2790.                             suicid_flag=FALSE;
  2791.                              error_indi=TRUE;
  2792.                         }
  2793.                         else
  2794.                         {
  2795.                              setpr(ownuid,65535);   /* set own priority to maximum ! */ 
  2796.  
  2797.                              kha=setpr(markpr,0);   /* set process priority to 0 !   */ 
  2798.                              if(kha!=-1)    
  2799.                              {
  2800.                                 _setsys(D_MinPty,2,1);    /* set MINPTY to 1 ! */
  2801.                                 if(ownuid==markpr)
  2802.                                     ownprior=newprior;
  2803.                                  gotoxy(1,23);
  2804.                                 printf(
  2805.                                  "\033[K\007\033[7;7m\033[5;5m SYSMON: \033[0;0m Process: %d  '%s' has been suspended !\n"
  2806.                                  ,markpr,killnam);
  2807.                                 if(logindi)
  2808.                                     fprintf(lpp,
  2809.                                      "\033[K\007\033[7;7m\033[5;5m SYSMON: \033[0;0m Process: %d  '%s' has been suspended !\n"
  2810.                                      ,markpr,killnam);
  2811.                                 get_cputime();
  2812.                                  error_indi=TRUE;
  2813.                                 ret_disp=100;
  2814.                             }
  2815.                               else
  2816.                             {
  2817.                                 gotoxy(1,23);
  2818.                                  printf(
  2819.                                  "\033[K\007\033[7;7m\033[5;5m SYSMON ERROR: \033[0;0m Process: '%s' ID: %d can't be suspend ! errno=%d \n"
  2820.                                  ,killnam,markpr,kha);
  2821.                                 if(logindi)
  2822.                                  fprintf(lpp,
  2823.                                  "\033[K\007\033[7;7m\033[5;5m SYSMON ERROR: \033[0;0m Process: '%s' ID: %d can't be suspend ! errno=%d \n"
  2824.                                  ,killnam,markpr,kha);
  2825.                              error_indi=TRUE;
  2826.                              }
  2827.                         }
  2828.                     }
  2829.                     else
  2830.                     {
  2831.                          kha=setpr(markpr,STANDARDPRIOR);
  2832.                          if(kha!=-1)
  2833.                          {
  2834.                             if(ownuid==markpr)
  2835.                                 ownprior=newprior;
  2836.                              gotoxy(1,23);
  2837.                             printf(
  2838.                              "\033[K\007\033[7;7m\033[5;5m SYSMON: \033[0;0m Process: %d  '%s' has been enabled !\n"
  2839.                              ,markpr,killnam);
  2840.                             if(logindi)
  2841.                                 fprintf(lpp,
  2842.                                  "\033[K\007\033[7;7m\033[5;5m SYSMON: \033[0;0m Process: %d  '%s' has been enabled !\n"
  2843.                                  ,markpr,killnam);
  2844.                             get_cputime();        
  2845.                              error_indi=TRUE;
  2846.                             ret_disp=100;
  2847.                          }
  2848.                          else
  2849.                         {
  2850.                             gotoxy(1,23);
  2851.                              printf(
  2852.                              "\033[K\007\033[7;7m\033[5;5m SYSMON ERROR: \033[0;0m Process: '%s' ID: %d can't be enabled ! errno=%d \n"
  2853.                              ,killnam,markpr,kha);
  2854.                             if(logindi)
  2855.                                  fprintf(lpp,
  2856.                                  "\033[K\007\033[7;7m\033[5;5m SYSMON ERROR: \033[0;0m Process: '%s' ID: %d can't be enabled ! errno=%d \n"
  2857.                                  ,killnam,markpr,kha);
  2858.                          error_indi=TRUE;
  2859.                          }
  2860.                     }
  2861.                 }
  2862.                  else
  2863.                  {
  2864.                      gotoxy(1,23);
  2865.                     printf(
  2866.                      "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m Operation canceled. Process: '%s' not suspend !\n"
  2867.                      ,killnam);
  2868.                     if(logindi)
  2869.                         fprintf(lpp,
  2870.                          "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m Operation canceled. Process: '%s' not suspend !\n"
  2871.                          ,killnam);
  2872.                     error_indi=TRUE;
  2873.                  }
  2874.                  spr_flag=FALSE;
  2875.             }
  2876.         }
  2877.         else
  2878.         {
  2879.               if(io_buff[0]=='~')                    
  2880.                 goto Goon;
  2881.  
  2882.               if(io_buff[0]!='A' && io_buff[0]!='G' && io_buff[0]!='U' &&
  2883.               io_buff[0]!='+' && io_buff[0]!='-' && io_buff[0]!='H' &&
  2884.             io_buff[0]!='N' && io_buff[0]!='S' && io_buff[0]!='<' &&
  2885.             io_buff[0]!='>' && io_buff[0]!='K' && io_buff[0]!='P' &&
  2886.             io_buff[0]!='F' && io_buff[0]!='D' && io_buff[0]!='R' &&
  2887.             io_buff[0]!='T' && io_buff[0]!='M' && io_buff[0]!='C' &&
  2888.             io_buff[0]!='B' && io_buff[0]!='W' && io_buff[0]!='J' &&
  2889.             io_buff[0]!='E' && io_buff[0]!='I' && io_buff[0]!='O' &&
  2890.             io_buff[0]!='X' && io_buff[0]!='L' && io_buff[0]!='Z' &&
  2891.             io_buff[0]!='1' && io_buff[0]!='2' && io_buff[0]!='V')
  2892.               {
  2893.                 gotoxy(1,23);
  2894.                 cursoroff();
  2895.                 gotoxy(1,23);
  2896.                 retstr=inkey(15,"\033[K\007\033[7;7m SYSMON: \033[0;0m \033[1;1mYou want to quit ?  ARE YOU SURE \033[5;5m\033[7;7m[Y/N]\033[0;0m ?");
  2897.  
  2898.                 switch(retstr)
  2899.                 {
  2900.                     case TRUE:
  2901.                             if(lpp)
  2902.                                 logindi=TRUE;
  2903.                             effect();
  2904.                             cls();
  2905.                             cursoron();
  2906.                            tmode(0,1);
  2907.                             if(logindi)
  2908.                             {
  2909.                                 fclose(lpp);
  2910.                                 logindi=FALSE;
  2911.                             }
  2912.                             switch_ctrl(RESTORE);
  2913.                             if(strncmp(portnam,"PKS",3)==0)
  2914.                                 sleep(2);
  2915.                             exit(0);
  2916.                             break;
  2917.                 
  2918.                     case TIMEOUT:
  2919.                             error_indi=TRUE;
  2920.                             gotoxy(1,23);
  2921.                             printf("%s",timeoutstr);
  2922.                             if(logindi)
  2923.                                 fprintf(lpp,"%s",timeoutstr);
  2924.                             break;
  2925.  
  2926.                     default:
  2927.                             error_indi=TRUE;
  2928.                             ret_disp=100;
  2929.                             gotoxy(1,23);
  2930.                             printf("\033[K\n");
  2931.                             if(logindi)
  2932.                                 fprintf(lpp,"\033[K\n");
  2933.                             break;
  2934.                   }
  2935.   
  2936.                 if(mode_flag)
  2937.                 {
  2938.                     gotoxy(1,23);
  2939.                     cursoron();
  2940.                 }
  2941.             }
  2942.  
  2943.               if(io_buff[0]=='W')
  2944.             {
  2945.                 if(privileg)
  2946.                 {
  2947.                     if(pwh)
  2948.                     {
  2949.                         if(watchy_flag)
  2950.                         {
  2951.                             watchy_flag=FALSE;
  2952.                             gotoxy(1,23);
  2953.                             printf("\033[K\007\033[7;7m\033[5;5m SYSMON: \033[0;0m WATCH-mode disabled !\n");
  2954.                             if(logindi)
  2955.                                 fprintf(lpp,
  2956.                                 "\033[K\007\033[7;7m\033[5;5m SYSMON: \033[0;0m WATCH-mode disabled !\n");
  2957.                             error_indi=TRUE;
  2958.                         }
  2959.                         else
  2960.                         {
  2961.                             watchy_flag=TRUE;
  2962.                             gotoxy(1,23);
  2963.                             printf("\033[K\007\033[7;7m\033[5;5m SYSMON: \033[0;0m WATCH-mode enabled ! [unkown user-processes will be killed]\n");
  2964.                             if(logindi)
  2965.                                 fprintf(lpp,
  2966.                                 "\033[K\007\033[7;7m\033[5;5m SYSMON: \033[0;0m WATCH-mode enabled ! [unkown user-processes will be killed]\n");
  2967.                             error_indi=TRUE;
  2968.                         }
  2969.                     }
  2970.                     else
  2971.                     {
  2972.                         gotoxy(1,23);
  2973.                         printf(
  2974.                         "\033[K\007\033[7;7m\033[5;5m SYSMON: \033[0;0m WATCH-mode can't be enabled !\n");
  2975.                         if(logindi)
  2976.                             fprintf(lpp,
  2977.                             "\033[K\007\033[7;7m\033[5;5m SYSMON: \033[0;0m WATCH-mode can't be enabled !\n");
  2978.                         error_indi=TRUE;
  2979.                     }
  2980.                 }
  2981.                 else
  2982.                 {
  2983.                     gotoxy(1,23);
  2984.                     printf("\033[K\007\033[7;7m\033[5;5m SYSMON: \033[0;0m No privilege for attempted operation ! errno=164\n");
  2985.                     if(logindi)
  2986.                         fprintf(lpp,"\033[K\007\033[7;7m\033[5;5m SYSMON: \033[0;0m No privilege for attempted operation ! errno=164\n");
  2987.                     error_indi=TRUE;
  2988.                 }
  2989.                 goto Goon;
  2990.             }
  2991.  
  2992.               if(io_buff[0]=='M')
  2993.             {
  2994.                 if(!mark)
  2995.                 {
  2996.                     mark=TRUE;
  2997.                     gotoxy(1,23);
  2998.                     printf(
  2999.                     "\033[K\007\033[7;7m SYSMON: \033[0;0m Mark-function enabled !\n");
  3000.                     if(logindi)
  3001.                         fprintf(lpp,
  3002.                         "\033[K\007\033[7;7m SYSMON: \033[0;0m Mark-function enabled !\n");
  3003.                     error_indi=TRUE;
  3004.                 }
  3005.                 else
  3006.                 {
  3007.                     mark=FALSE;
  3008.                     gotoxy(1,23);
  3009.                     printf(
  3010.                     "\033[K\007\033[7;7m SYSMON: \033[0;0m Mark-function disabled !\n");
  3011.                     if(logindi)
  3012.                         fprintf(lpp,
  3013.                         "\033[K\007\033[7;7m SYSMON: \033[0;0m Mark-function disabled !\n");
  3014.                     error_indi=TRUE;
  3015.                 }
  3016.                 goto Goon;
  3017.             }
  3018.  
  3019.               if(io_buff[0]=='C')
  3020.             {
  3021.                 if(!clflg)
  3022.                     clflg=TRUE;
  3023.                 else
  3024.                     clflg=FALSE;
  3025.                 goto Goon;
  3026.             }
  3027.  
  3028.               if(io_buff[0]=='R')
  3029.             {
  3030.                 if(!killer && !susy_flag)
  3031.                 {
  3032.                     if(reference)
  3033.                     {
  3034.                         reference=FALSE;
  3035.                         error_indi=TRUE;
  3036.                         gotoxy(1,23);
  3037.                         if(maxh_flag)
  3038.                         {
  3039.                             printf("\033[K%s \n",maxhstr);
  3040.                             if(logindi)
  3041.                                 fprintf(lpp,"\033[K%s \n",maxhstr);
  3042.                         }    
  3043.                         else
  3044.                         {
  3045.                             printf("\033[K\n");
  3046.                             if(logindi)
  3047.                                 fprintf(lpp,"\033[K\n");
  3048.                         }
  3049.                         ret_disp=100;
  3050.                     }
  3051.                     else
  3052.                     {
  3053.                         reference=TRUE;
  3054.                         error_indi=FALSE;
  3055.                         gotoxy(1,23);
  3056.                         printf("\033[K%s\n",referstr);
  3057.                         if(logindi)
  3058.                             fprintf(lpp,"\033[K%s\n",referstr);
  3059.                    }
  3060.                 }
  3061.                 goto Goon;
  3062.             }
  3063.  
  3064.  
  3065.               if(io_buff[0]=='N')
  3066.               {
  3067.                 error_indi=FALSE;
  3068.                   if(name_flag)
  3069.                 {
  3070.                 name_flag=FALSE;
  3071.                     if(pwh)
  3072.                     {
  3073.                         cls();
  3074.                     switch (mode_flag)
  3075.                     {
  3076.                         case 0:
  3077.                                 display_frame();
  3078.                             break;
  3079.                             case 1:
  3080.                                 display_dframe();
  3081.                                 break;
  3082.                         }
  3083.                 }
  3084.                 }
  3085.                 else
  3086.                 {
  3087.                     if(pwh)
  3088.                     {
  3089.                        name_flag=TRUE;
  3090.                         cls();
  3091.                     switch (mode_flag)
  3092.                     {
  3093.                         case 0:
  3094.                                 display_frame();
  3095.                             break;
  3096.                             case 1:
  3097.                                 display_dframe();
  3098.                                 break;
  3099.                     }
  3100.                     }
  3101.                     else
  3102.                     {
  3103.                         if(passerror==214 || passerror==164)
  3104.                         {
  3105.                             gotoxy(1,23);
  3106.                             printf("\033[K\007\033[7;7m\033[5;5m SYSMON: \033[0;0m No privilege for attempted operation ! errno=%d \n",passerror);
  3107.                             if(logindi)
  3108.                                 fprintf(lpp,"\033[K\007\033[7;7m\033[5;5m SYSMON: \033[0;0m No privilege for attempted operation ! errno=%d \n",passerror);
  3109.                             error_indi=TRUE;
  3110.                         }
  3111.                         else
  3112.                         {
  3113.                             gotoxy(1,23);
  3114.                             printf("\033[K\007\033[7;7m\033[5;5m SYSMON-ERROR: \033[0;0m No passwordfile found, can't switch to NAME-mode !\n");
  3115.                             if(logindi)
  3116.                                 fprintf(lpp,"\033[K\007\033[7;7m\033[5;5m SYSMON-ERROR: \033[0;0m No passwordfile found, can't switch to NAME-mode !\n");
  3117.                             error_indi=TRUE;
  3118.                         }
  3119.                    }                
  3120.                }
  3121.                 goto Goon;
  3122.             }
  3123.  
  3124.               if(io_buff[0]=='H')
  3125.               {
  3126.                 cursoroff();
  3127.                 error_indi=FALSE;
  3128.                 retstr=show_version();
  3129.                 if(!retstr)
  3130.                 {
  3131.                     retstr=inkey(0,"\033[7;7m Press any key or 'Q' for previous screen \033[0;0m");
  3132.                     if(!retstr)
  3133.                     {
  3134.                         helpuser();
  3135.                         retstr=inkey(0,
  3136.                         "\033[7;7m Press any key to continue ... \033[0;0m");
  3137.                     }
  3138.                 }
  3139.                 effect();
  3140.                 cls();
  3141.                if(!mode_flag)
  3142.                     display_frame();
  3143.                 else
  3144.                     display_dframe();
  3145.                 goto Goon;
  3146.               }        
  3147.  
  3148.               if(io_buff[0]=='X')
  3149.             {
  3150.                 if(privileg)                    /* is user privileged ? */
  3151.                 {
  3152.                     if(reset_flag)              /* reset allowed from source ? */
  3153.                     {
  3154.                         kha=checkadr(0x4);    /* adress resetvector of CPU ! */
  3155.                         if(!kha)
  3156.                         {
  3157.                             retstr=inkey(15,"\033[K\007\033[7;7m\033[1;1m\033[5;5m WARNING: \033[0;0m THE SYSTEM WILL BE RESETTED ! \033[1;1m\033[5;5m ARE YOU SURE [Y/N] ???\033[0;0m\n");
  3158.  
  3159.                             switch(retstr)
  3160.                             {
  3161.                                 case TRUE:
  3162.                                     cls();
  3163.                                     cursoron();
  3164.                                     tsleep(10);
  3165.                                     reseter();
  3166.                                     switch_ctrl(RESTORE);
  3167.                                     if(strncmp(portnam,"PKS",3)==0)
  3168.                                         sleep(2);
  3169.                                     exit(0);
  3170.                                     break;
  3171.  
  3172.                                 case TIMEOUT:
  3173.                                     gotoxy(1,23);
  3174.                                     printf("%s",timeoutstr);
  3175.                                     if(logindi)
  3176.                                         fprintf(lpp,"%s",timeoutstr);
  3177.                                     error_indi=TRUE;
  3178.                                     break;
  3179.  
  3180.                                 default:
  3181.                                     gotoxy(1,23);
  3182.                                     printf("\033[K\n");
  3183.                                     if(logindi)
  3184.                                         fprintf(lpp,"\033[K\n");
  3185.                                     error_indi=TRUE;
  3186.                                     ret_disp=100;
  3187.                                     break;
  3188.                             }
  3189.                         }
  3190.                         else
  3191.                         {
  3192.                             retstr=Permit(0,4096,3);
  3193.                             if(retstr==-1)
  3194.                             {
  3195.                                 gotoxy(1,23);
  3196.                                 printf("%s\n",mmu_errstr);
  3197.                                 if(logindi)
  3198.                                     fprintf(lpp,"%s",mmu_errstr);
  3199.                                 error_indi=TRUE;
  3200.                             }
  3201.                             else
  3202.                             {
  3203.                                 kha=checkadr(0x4);    /* adress resetvector of CPU ! */
  3204.                                 if(!kha)
  3205.                                 {
  3206.                                     retstr=inkey(15,"\033[K\007\033[7;7m\033[1;1m\033[5;5m WARNING: \033[0;0m THE MMU-SYSTEM WILL BE RESETTED ! \033[1;1m\033[5;5m ARE YOU SURE [Y/N] ???\033[0;0m\n");
  3207.  
  3208.                                     switch(retstr)
  3209.                                     {
  3210.                                         case TRUE:
  3211.                                             cls();
  3212.                                             cursoron();
  3213.                                             tsleep(10);
  3214.                                             reseter();
  3215.                                             switch_ctrl(RESTORE);
  3216.                                             if(strncmp(portnam,"PKS",3)==0)
  3217.                                                 sleep(2);
  3218.                                             exit(0);
  3219.                                             break;
  3220.  
  3221.                                         case TIMEOUT:
  3222.                                             if(Protect(0,4096)!=0)
  3223.                                             {
  3224.                                                     kha=errno;
  3225.                                                 cls();
  3226.                                                 cursoron();
  3227.                                                    tmode(0,1);
  3228.                                                     if(logindi)
  3229.                                                     {
  3230.                                                         fclose(lpp);
  3231.                                                         logindi=FALSE;
  3232.                                                     }
  3233.                                                     switch_ctrl(RESTORE);
  3234.                                                     if(strncmp(portnam,"PKS",3)==0)
  3235.                                                         sleep(2);
  3236.                                                     exit(kha);
  3237.                                             }
  3238.                                             gotoxy(1,23);
  3239.                                             printf("%s",timeoutstr);
  3240.                                             if(logindi)
  3241.                                                 fprintf(lpp,"%s",timeoutstr);
  3242.                                             error_indi=TRUE;
  3243.                                             break;
  3244.  
  3245.                                         default:
  3246.                                             if(Protect(0,4096)!=0)
  3247.                                             {
  3248.                                                     kha=errno;
  3249.                                                 cls();
  3250.                                                 cursoron();
  3251.                                                    tmode(0,1);
  3252.                                                     if(logindi)
  3253.                                                     {
  3254.                                                         fclose(lpp);
  3255.                                                         logindi=FALSE;
  3256.                                                     }
  3257.                                                     switch_ctrl(RESTORE);
  3258.                                                     if(strncmp(portnam,"PKS",3)==0)
  3259.                                                         sleep(2);
  3260.                                                     exit(kha);
  3261.                                             }
  3262.                                             gotoxy(1,23);
  3263.                                             printf("\033[K\n");
  3264.                                             if(logindi)
  3265.                                                 fprintf(lpp,"\033[K\n");
  3266.                                             error_indi=TRUE;
  3267.                                             ret_disp=100;
  3268.                                             break;
  3269.                                     }
  3270.                                 }
  3271.                                 else
  3272.                                 {
  3273.                                     gotoxy(1,23);
  3274.                                     printf("%s\n",mmu_errstr);
  3275.                                     if(logindi)
  3276.                                         fprintf(lpp,"%s\n",mmu_errstr);
  3277.                                     error_indi=TRUE;
  3278.                                     if(Protect(0,4096)!=0)
  3279.                                     {
  3280.                                         kha=errno;
  3281.                                         cursoron();
  3282.                                        tmode(0,1);
  3283.                                         if(logindi)
  3284.                                         {
  3285.                                             fclose(lpp);
  3286.                                             logindi=FALSE;
  3287.                                         }
  3288.                                         switch_ctrl(RESTORE);
  3289.                                         if(strncmp(portnam,"PKS",3)==0)
  3290.                                             sleep(2);
  3291.                                         exit(kha);
  3292.                                     }
  3293.                                 }
  3294.                             }
  3295.                         }
  3296.                     }
  3297.                     else
  3298.                     {
  3299.                         gotoxy(1,23);
  3300.                         printf(
  3301.                         "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m No privilege for attempted operation from this source ! errno=164 \n");
  3302.                         if(logindi)
  3303.                             fprintf(lpp,
  3304.                             "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m No privilege for attempted operation from this source ! errno=164 \n");
  3305.                         error_indi=TRUE;
  3306.                     }
  3307.                }
  3308.                 else
  3309.                 {
  3310.                     gotoxy(1,23);
  3311.                     printf(
  3312.                     "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m No privilege for attempted operation ! errno=164 \n");
  3313.                     if(logindi)
  3314.                         fprintf(lpp,
  3315.                         "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m No privilege for attempted operation ! errno=164 \n");
  3316.                     error_indi=TRUE;
  3317.                 }
  3318.                 goto Goon;
  3319.             }
  3320.  
  3321.               if(io_buff[0]=='L')
  3322.             {
  3323.                 if(privileg)
  3324.                 {
  3325.                     momage=_getsys(D_MinPty,2);
  3326.                     if(momage>0)
  3327.                     {
  3328.                         if(suspendcount>0)
  3329.                             sprintf(messagebuf,
  3330.                             "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m ALL %d SUSPENDED PROCESSES WILL BE ENABLED ! \033[1;1m\033[5;5m ARE YOU SURE ? [Y/N] \033[0;0m\n",suspendcount);
  3331.                         else
  3332.                             sprintf(messagebuf,
  3333.                             "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m RESET MINAGE ? \033[1;1m\033[5;5m ARE YOU SURE ? [Y/N] \033[0;0m\n",suspendcount);
  3334.     
  3335.                         retstr=inkey(30,messagebuf);  /* 30 seconds timeout ! */
  3336.                         if(retstr==TRUE)
  3337.                         {
  3338.                             remove_flag=TRUE;
  3339.                             get_cputime();
  3340.                             remove_flag=FALSE;
  3341.                             suspendcount=0;
  3342.                             _setsys(D_MinPty,2,0);
  3343.                         }
  3344.                         gotoxy(1,23);
  3345.                         printf("\033[K\n");
  3346.                         if(logindi)
  3347.                             fprintf(lpp,"\033[K\n");
  3348.                         error_indi=TRUE;
  3349.                         ret_disp=100;
  3350.                     }
  3351.                     else
  3352.                     {
  3353.                         gotoxy(1,23);
  3354.                         printf("\033[K\007\033[7;7m SYSMON: \033[0;0m There are no suspended processes to enable !\n");
  3355.                         if(logindi)
  3356.                             fprintf(lpp,"\033[K\007\033[7;7m SYSMON: \033[0;0m There are no suspended processes to enable !\n");
  3357.                         error_indi=TRUE;
  3358.                     }
  3359.                }
  3360.                 else
  3361.                 {
  3362.                     gotoxy(1,23);
  3363.                     printf(
  3364.                     "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m No privilege for attempted operation ! errno=164 \n");
  3365.                     if(logindi)
  3366.                         fprintf(lpp,
  3367.                         "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m No privilege for attempted operation ! errno=164 \n");
  3368.                     error_indi=TRUE;
  3369.                 }
  3370.                 goto Goon;
  3371.             }
  3372.  
  3373.              if(io_buff[0]=='F')
  3374.             {
  3375.                 if(privileg)
  3376.                 {
  3377.                       icpt_flag=FALSE;
  3378.                     error_indi=FALSE;
  3379.                     gotoxy(1,23);
  3380.                     cursoroff();
  3381.  
  3382.                     sshell=(char *) getenv("SHELL");
  3383.                     if(sshell!=0)
  3384.                     {
  3385.                         sprintf(ushell,"%s",sshell);
  3386.                         uppercase(ushell);
  3387.                         gotoxy(1,23);
  3388.                         printf(
  3389.                         "\033[K\033[7;7m SYSMON: \033[0;0m Trying to fork a '%s' ...\n",ushell);
  3390.                         if(logindi)
  3391.                             fprintf(lpp,
  3392.                             "\033[K\033[7;7m SYSMON: \033[0;0m Trying to fork a '%s' ...\n",ushell);
  3393.                         tmode(0,1);
  3394.                         sleep(1);
  3395.  
  3396.                         gotoxy(1,23);
  3397.                         cursoron();
  3398.                         switch_ctrl(ON);
  3399.  
  3400.                         sprintf(argblk[0],"%s",ushell);
  3401.                         if(strncmp("ZSH",ushell,3)==0)
  3402.                             sprintf(argblk[1],"-eyp=\"SYSMON:[''cdir']>\"");
  3403.                         else
  3404.                             sprintf(argblk[1],"-ep=\"SYSMON:%s> \"",ushell);
  3405.  
  3406.                         forkh = os9exec(os9fork,argblk[0],argblk,environa,
  3407.                         0,orginatprior,3);
  3408.                         if(forkh==-1)
  3409.                         {
  3410.                         switch_ctrl(OFF);
  3411.                             gotoxy(1,23);
  3412.                             cursoroff();
  3413.                             gotoxy(1,23);
  3414.                             printf(
  3415.                             "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON ERROR: \033[0;0m Sorry can't fork '%s' ! errno=%d\n"
  3416.                             ,ushell,errno);
  3417.                             if(logindi)
  3418.                                 fprintf(lpp,
  3419.                                 "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON ERROR: \033[0;0m Sorry can't fork '%s' ! errno=%d\n"
  3420.                                 ,ushell,errno);
  3421.                             sleep(3);
  3422.                             if(strncmp("SHELL",ushell,4)!=0)
  3423.                             {
  3424.                                 retstr=inkey(15,
  3425.                                 "\033[K\007\033[7;7m SYSMON: \033[0;0m\033[1;1m Do You want to fork a 'SHELL' ?  \033[5;5m\033[7;7m[Y/N]\033[0;0m");
  3426.                                 switch(retstr)
  3427.                                 {
  3428.                                     case TRUE:
  3429.                                         switch_ctrl(OFF);
  3430.                                         gotoxy(1,23);
  3431.                                         cursoroff();
  3432.                                         gotoxy(1,23);
  3433.                                         printf(
  3434.                                         "\033[K\033[7;7m SYSMON: \033[0;0m Ok !  Now trying to fork a SHELL ...\n");
  3435.                                         if(logindi)
  3436.                                         fprintf(lpp,
  3437.                                         "\033[K\033[7;7m SYSMON: \033[0;0m Ok !  Now trying to fork a SHELL ...\n");
  3438.                                         sleep(1);
  3439.                                         goto Alternativ;
  3440.                                         break;                
  3441.                                     case TIMEOUT:
  3442.                                         error_indi=TRUE;
  3443.                                         gotoxy(1,23);
  3444.                                         printf("%s",timeoutstr);
  3445.                                         if(logindi)
  3446.                                             fprintf(lpp,"%s",timeoutstr);
  3447.                                         sleep(2);
  3448.                                         break;
  3449.                                     default:
  3450.                                         error_indi=TRUE;
  3451.                                         ret_disp=100;
  3452.                                         gotoxy(1,23);
  3453.                                         printf("\033[K\n");
  3454.                                         if(logindi)
  3455.                                             fprintf(lpp,"\033[K\n");
  3456.                                         break;
  3457.                                 }
  3458.                             }
  3459.                           }
  3460.                         else
  3461.                         {
  3462.                             fid=forkh;
  3463.                             forkh=wait(0);
  3464.                             switch_ctrl(OFF);
  3465.                             gotoxy(1,23);
  3466.                             cursoroff();
  3467.                             cls();
  3468.                             gotoxy(1,23);
  3469.                             printf(
  3470.                             "\033[K\007\033[7;7m SYSMON: \033[0;0m Process: %d  '%s' terminated !\n",
  3471.                             fid,ushell);
  3472.                             if(logindi)
  3473.                                 fprintf(lpp,
  3474.                                 "\033[K\007\033[7;7m SYSMON: \033[0;0m Process: %d  '%s' terminated !\n",
  3475.                                 fid,ushell);
  3476.                             tsleep(50);
  3477.                             olddelay=delay;
  3478.                             delay=2;
  3479.                             get_cputime();
  3480.                             delay=olddelay;
  3481.                         }
  3482.                         cls();
  3483.                         tmode(0,0);
  3484.                         refresh_flag=TRUE;
  3485.                     }
  3486.                     else
  3487.                     {
  3488.                         gotoxy(1,23);
  3489.                         printf(
  3490.                         "\033[K\033[7;7m SYSMON: \033[0;0m Environment variable SHELL not set ! Trying to fork a ZSH ...\n");
  3491.                         if(logindi)
  3492.                             fprintf(lpp,
  3493.                             "\033[K\033[7;7m SYSMON: \033[0;0m Environment variable SHELL not set ! Trying to fork a ZSH ...\n");
  3494.                         tmode(0,1);
  3495.                         sleep(1);
  3496.  
  3497.                         gotoxy(1,23);
  3498.                         cursoron();
  3499.                         switch_ctrl(ON);
  3500.  
  3501.                         sprintf(argblk[0],"%s/cmds/zsh",ddnam);
  3502.                         sprintf(argblk[1],"-eyp=\"SYSMON:[''cdir']>\"");
  3503.  
  3504.                         forkh = os9exec(os9fork,argblk[0],argblk,environa,
  3505.                         0,orginatprior,3);
  3506.                         if(forkh==-1)
  3507.                         {
  3508.                             switch_ctrl(OFF);
  3509.                             gotoxy(1,23);
  3510.                             cursoroff();
  3511.                             gotoxy(1,23);
  3512.                             printf(
  3513.                             "\033[K\033[7;7m SYSMON: \033[0;0m No ZSH found ! Trying to fork a SHELL ...\n");
  3514.                             if(logindi)
  3515.                                 fprintf(lpp,
  3516.                                 "\033[K\033[7;7m SYSMON: \033[0;0m No ZSH found ! Trying to fork a SHELL ...\n");
  3517.                             sleep(1);
  3518.  
  3519.                         Alternativ:
  3520.                             gotoxy(1,23);
  3521.                             cursoron();
  3522.                             cls();
  3523.                             gotoxy(1,23);
  3524.                             fflush(stdout);
  3525.                                switch_ctrl(ON);
  3526.  
  3527.                          sprintf(argblk[0],"%s/cmds/shell",ddnam);
  3528.                             sprintf(argblk[1],"-ep=\"SYSMON:SHELL>\"");
  3529.                             forkh = os9exec(os9fork,argblk[0],argblk,environa,
  3530.                             0,orginatprior,3);
  3531.                             if(forkh!=-1)
  3532.                             {
  3533.                                 fid=forkh;
  3534.                                 forkh=wait(0);
  3535.                                 switch_ctrl(OFF);
  3536.                                 gotoxy(1,23);
  3537.                                 cursoroff();
  3538.                             cls();
  3539.                                 gotoxy(1,23);
  3540.                                 printf("\033[K\007\033[7;7m SYSMON: \033[0;0m Process: %d  'SHELL' terminated !\n",fid);
  3541.                                 if(logindi)
  3542.                                     fprintf(lpp,
  3543.                                     "\033[K\007\033[7;7m SYSMON: \033[0;0m Process: %d  'SHELL' terminated !\n",fid);
  3544.                                 tsleep(50);
  3545.                                 olddelay=delay;
  3546.                                 delay=2;
  3547.                                 get_cputime();
  3548.                                 delay=olddelay;
  3549.                             }
  3550.                             else
  3551.                             {
  3552.                             switch_ctrl(OFF);
  3553.                                 gotoxy(1,23);
  3554.                                 cursoroff();
  3555.                                 gotoxy(1,23);
  3556.                                 printf(
  3557.                                 "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON ERROR: \033[0;0m Sorry can't fork ZSH or SHELL ! errno=%d\n"
  3558.                                 ,errno);
  3559.                                 if(logindi)
  3560.                                 fprintf(lpp,
  3561.                                     "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON ERROR: \033[0;0m Sorry can't fork ZSH or SHELL ! errno=%d\n"
  3562.                                     ,errno);
  3563.                                 sleep(4);
  3564.                             }
  3565.                         }
  3566.                         else
  3567.                         {
  3568.                             fid=forkh;
  3569.                             forkh=wait(0);
  3570.                             switch_ctrl(OFF);
  3571.                             gotoxy(1,23);
  3572.                             cursoroff();
  3573.                             cls();
  3574.                             gotoxy(1,23);
  3575.                             printf(
  3576.                             "\033[K\007\033[7;7m SYSMON: \033[0;0m Process: %d  'ZSH' terminated !\n",fid);
  3577.                             if(logindi)
  3578.                                 fprintf(lpp,
  3579.                                 "\033[K\007\033[7;7m SYSMON: \033[0;0m Process: %d  'ZSH' terminated !\n",fid);
  3580.                             tsleep(50);
  3581.                             olddelay=delay;
  3582.                             delay=2;
  3583.                             get_cputime();
  3584.                             delay=olddelay;
  3585.                         }
  3586.                         cls();
  3587.                         tmode(0,0);
  3588.                         refresh_flag=TRUE;
  3589.                    }
  3590.                 }
  3591.                 else        /* user is not priviledged ! */
  3592.                 {
  3593.                       icpt_flag=FALSE;
  3594.                     error_indi=FALSE;
  3595.                     tmode(0,1);
  3596.                     cursoron();
  3597.                        switch_ctrl(ON);
  3598.                     cls();
  3599.                     gotoxy(1,23);
  3600.                     fflush(stdout);
  3601.  
  3602.                  sprintf(argblk[0],"%s/cmds/login",ddnam);
  3603.                     sprintf(argblk[1],"");
  3604.                     forkh = os9exec(os9fork,argblk[0],argblk,environa,
  3605.                     0,orginatprior,3);
  3606.                     if(forkh!=-1)
  3607.                     {
  3608.                            fid=forkh;
  3609.                            forkh=wait(0);
  3610.                            switch_ctrl(OFF);
  3611.                            gotoxy(1,23);
  3612.                            cursoroff();
  3613.                        cls();
  3614.                            gotoxy(1,23);
  3615.                            printf("\033[K\007\033[7;7m SYSMON: \033[0;0m Process: %d  'LOGIN' terminated !\n",fid);
  3616.                            if(logindi)
  3617.                                fprintf(lpp,
  3618.                                "\033[K\007\033[7;7m SYSMON: \033[0;0m Process: %d  'LOGIN' terminated !\n",fid);
  3619.                            tsleep(50);
  3620.                            olddelay=delay;
  3621.                            delay=2;
  3622.                            get_cputime();
  3623.                            delay=olddelay;
  3624.                     }
  3625.                     else
  3626.                     {
  3627.                     switch_ctrl(OFF);
  3628.                         gotoxy(1,23);
  3629.                         cursoroff();
  3630.                         gotoxy(1,23);
  3631.                         printf(
  3632.                         "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON ERROR: \033[0;0m Sorry can't fork 'login' ! errno=%d\n"
  3633.                         ,errno);
  3634.                         if(logindi)
  3635.                                fprintf(lpp,
  3636.                             "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON ERROR: \033[0;0m Sorry can't fork 'login' ! errno=%d\n"
  3637.                             ,errno);
  3638.                         sleep(4);
  3639.                     }
  3640.                     tmode(0,0);
  3641.                     refresh_flag=TRUE;
  3642.                 }
  3643.                 goto Goon;
  3644.             }
  3645.  
  3646.              if(io_buff[0]=='I')
  3647.             {
  3648.                 if(privileg)  /* is the user privileged ???? */
  3649.                 {
  3650.                 gotoxy(1,23);
  3651.                     printf("%s \n",readingpassstr);
  3652.                     if(logindi)
  3653.                         fprintf(lpp,"%s \n",readingpassstr);
  3654.                     icpt_flag=TRISTATE;
  3655.                     pwh=get_password();
  3656.                     if(!pwh)
  3657.                     {
  3658.                         name_flag=FALSE;
  3659.                         gotoxy(1,23);
  3660.                         printf("%s \n",readpasserrstr);
  3661.                         if(logindi)
  3662.                             fprintf(lpp,"%s \n",readpasserrstr);
  3663.                         refresh_flag=TRUE;
  3664.                         sleep(2);
  3665.                     }
  3666.                     else
  3667.                     {
  3668.                         sleep(1);
  3669.                         gotoxy(1,23);
  3670.                         printf("\033[K\n");
  3671.                         if(logindi)
  3672.                             fprintf(lpp,"\033[K\n");
  3673.                         error_indi=TRUE;
  3674.                         ret_disp=100;
  3675.                     }
  3676.                 }
  3677.                 else
  3678.                 {
  3679.                     gotoxy(1,23);
  3680.                     printf(
  3681.                     "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m No privilege for attempted operation ! errno=164 \n");
  3682.                     if(logindi)
  3683.                         fprintf(lpp,
  3684.                         "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m No privilege for attempted operation ! errno=164 \n");
  3685.                     error_indi=TRUE;
  3686.                 }
  3687.                 goto Goon;
  3688.             }
  3689.  
  3690.              if(io_buff[0]=='G')
  3691.               {
  3692.                 effect();
  3693.                 cls();
  3694.                 susy_flag=FALSE;
  3695.                 error_indi=FALSE;
  3696.                 lastcount=0;
  3697.                 mode_flag=0;
  3698.                 active_flag=0;
  3699.                 scc=1;
  3700.                 startc=0;
  3701.                    actualcount=0;
  3702.                 display_frame();
  3703.                 goto Goon;
  3704.               }
  3705.  
  3706.             if(io_buff[0]=='J')
  3707.             {
  3708.                 gotoxy(1,23);
  3709.                 if(maxh_flag)
  3710.                 {
  3711.                     maxh_flag=FALSE;
  3712.                     printf("\033[K%s \n",maxhdstr);
  3713.                     if(logindi)
  3714.                         fprintf(lpp,"\033[K%s \n",maxhdstr);
  3715.                     error_indi=TRUE;
  3716.                 }
  3717.                 else
  3718.                 {
  3719.                      maxh_flag=TRUE;
  3720.                     printf("\033[K%s \n",maxhstr);
  3721.                     if(logindi)
  3722.                         fprintf(lpp,"\033[K%s \n",maxhstr);
  3723.                }    
  3724.                 for(i=0;i<MAXPROCS;maxprocent[i++]=0);
  3725.                 goto Goon;
  3726.             }
  3727.  
  3728.              if(io_buff[0]=='D')
  3729.             {
  3730.                 gotoxy(1,23);
  3731.                 cursoroff();
  3732.                 error_indi=TRUE;
  3733.                 gotoxy(1,23);
  3734.                 printf(
  3735.                 "\033[K\033[7;7m SYSMON: \033[0;0m CURRENT DELAY: %2d sec. Change with [+/-] - keys. Set delay with [CR] !\n",delay);
  3736.                 if(logindi)
  3737.                     fprintf(lpp,
  3738.                     "\033[K\033[7;7m SYSMON: \033[0;0m CURRENT DELAY: %2d sec. Change with [+/-] - keys. Set delay with [CR] !\n",delay);
  3739.                 for(i=0;i<500;i++)
  3740.                 {
  3741.                     io_buff[0]=0;
  3742.                     ptaste=_gs_rdy(0);
  3743.                       if(ptaste!=-1)
  3744.                       {
  3745.                         i=0;
  3746.                         read(0,ptastbuff,ptaste);
  3747.                            
  3748.                          if(ptastbuff[0]=='+' && delay<60)
  3749.                                delay++;
  3750.  
  3751.                        if(ptastbuff[0]=='-' && delay>mindelay)
  3752.                             delay--;
  3753.     
  3754.                     if(ptastbuff[0]==13)
  3755.                             break;
  3756.                         gotoxy(26,23);
  3757.                         printf("%2d\n",delay);
  3758.                         if(logindi)
  3759.                             fprintf(lpp,"%2d\n",delay);
  3760.                 }
  3761.                     if(ptaste==-1)
  3762.                           tsleep(5);
  3763.                 }
  3764.  
  3765.                 if(i>=500)              /* timeout ??? */
  3766.                 {
  3767.                     gotoxy(1,23);
  3768.                     printf("%s",timeoutstr);
  3769.                     if(logindi)
  3770.                         fprintf(lpp,"%s",timeoutstr);
  3771.                 }
  3772.                 else
  3773.                 {
  3774.                     ret_disp=100;
  3775.                     gotoxy(1,23);
  3776.                     printf("\033[K\n");
  3777.                     if(logindi)
  3778.                         fprintf(lpp,"\033[K\n");
  3779.                 }
  3780.  
  3781.                 if(mode_flag)
  3782.                 {
  3783.                     gotoxy(1,23);
  3784.                     cursoron();
  3785.                 }
  3786.                 goto Goon;
  3787.                }
  3788.  
  3789.  
  3790.               if(io_buff[0]=='A' || io_buff[0]=='B' ||
  3791.             io_buff[0]=='E' || io_buff[0]=='V')
  3792.               {
  3793.                 effect();
  3794.                 cls();
  3795.                 error_indi=FALSE;
  3796.                 susy_flag=FALSE;
  3797.                 startc=0;
  3798.                 scc=1;
  3799.                    actualcount=0;
  3800.                 lastcount=0;
  3801.                 mode_flag=1;
  3802.                 active_flag=0;
  3803.                 switch(io_buff[0])
  3804.                 {
  3805.                     case 'A':
  3806.                         exmode=FALSE;
  3807.                         break;
  3808.                     case 'B':
  3809.                         exmode=TRUE;
  3810.                         break;
  3811.                     case 'E':
  3812.                         exmode=2;
  3813.                         break;
  3814.                     case 'V':
  3815.                         exmode=3;
  3816.                         break;
  3817.                 }
  3818.                 display_dframe();
  3819.                 goto Goon;
  3820.               }
  3821.  
  3822.               if(io_buff[0]=='U')
  3823.               {
  3824.                 effect();
  3825.                 cls();
  3826.                 error_indi=FALSE;
  3827.                 susy_flag=FALSE;
  3828.                 scc=1;
  3829.                 startc=0;
  3830.                 lastcount=0;
  3831.                    actualcount=0;
  3832.                 mode_flag=1;
  3833.                 active_flag=1;
  3834.                 display_dframe();
  3835.                 goto Goon;
  3836.               }
  3837.  
  3838.               if(io_buff[0]=='S') 
  3839.               {
  3840.                 error_indi=FALSE;
  3841.                 if(privileg)  /* is the user privileged ???? */
  3842.                 {
  3843.                     reference=FALSE;                      /* switch of reference */  
  3844.                     if(mode_flag==1 && !active_flag)      /* only in */
  3845.                    {                                      /*alpha mode ! */
  3846.                         if(!susy_flag)
  3847.                         {                    
  3848.                             susy_flag=TRUE;
  3849.                             watchy_flag=FALSE;
  3850.                             under_title();
  3851.                         }
  3852.                         else
  3853.                         {
  3854.                              susy_flag=FALSE;
  3855.                             under_title();
  3856.                         }
  3857.                     }
  3858.                     else
  3859.                     {
  3860.                         cls();
  3861.                         lastcount=0;
  3862.                         mode_flag=1;
  3863.                         scc=1;
  3864.                         startc=0;
  3865.                         actualcount=0;
  3866.                         active_flag=0;
  3867.                         susy_flag=TRUE;
  3868.                     display_dframe();  
  3869.                     }
  3870.                 }
  3871.                 else
  3872.                 {
  3873.                     gotoxy(1,23);
  3874.                     printf(
  3875.                     "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m No privilege for attempted operation ! errno=164 \n");
  3876.                     if(logindi)
  3877.                         fprintf(lpp,
  3878.                         "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m No privilege for attempted operation ! errno=164 \n");
  3879.                     error_indi=TRUE;
  3880.                 }
  3881.                 goto Goon;
  3882.               }    
  3883.       
  3884.               if(io_buff[0]=='>')
  3885.               {
  3886.                 if(susy_flag)
  3887.                 {
  3888.                     if(scc<(fa+fb)) 
  3889.                     {
  3890.                         scc++;
  3891.                         startc++;
  3892.                         selecta=TRUE;
  3893.                     }
  3894.                     else
  3895.                     {
  3896.                     if(actualcount<imax-15)
  3897.                       {    
  3898.                         error_indi=FALSE;
  3899.                         actualcount+=16;
  3900.                             under_title();
  3901.                             startc=0;
  3902.                             scc++;
  3903.                         }
  3904.                         else
  3905.                         {
  3906.                             gotoxy(1,23);
  3907.                             printf("%s\n",reached_endstr);
  3908.                             if(logindi)
  3909.                                 fprintf(lpp,"%s\n",reached_endstr);
  3910.                             error_indi=TRUE;
  3911.                         }
  3912.                       }
  3913.                   }
  3914.                 else
  3915.                 {
  3916.                     gotoxy(1,23);
  3917.                     printf(
  3918.                     "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m SELECT-MODE not enabled.  Use 'S' key to enable !\n");
  3919.                     if(logindi)
  3920.                         fprintf(lpp,
  3921.                         "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m SELECT-MODE not enabled.  Use 'S' key to enable !\n");
  3922.                     error_indi=TRUE;
  3923.                 }
  3924.                 goto Goon;
  3925.               }
  3926.  
  3927.  
  3928.               if(io_buff[0]=='<')
  3929.               {
  3930.                 if(susy_flag)
  3931.                 {
  3932.                     if(scc>fa+1)
  3933.                     {
  3934.                         selecta=TRUE;
  3935.                         scc--;
  3936.                         startc--;
  3937.                     }
  3938.                     else
  3939.                     {
  3940.                         if(actualcount>=16)
  3941.                         {
  3942.                             error_indi=FALSE;
  3943.                             actualcount-=16;
  3944.                             under_title();
  3945.                             scc--;
  3946.                             startc=15;
  3947.                         }
  3948.                         else
  3949.                         {
  3950.                             actualcount=0;
  3951.                             gotoxy(1,23);
  3952.                             printf("%s\n",reached_beginstr);
  3953.                             if(logindi)
  3954.                                 fprintf(lpp,"%s\n",reached_beginstr);
  3955.                             error_indi=TRUE;
  3956.                         }
  3957.                     }
  3958.                 }
  3959.                 else
  3960.                 {
  3961.                     gotoxy(1,23);
  3962.                     printf(
  3963.                     "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m SELECT-MODE not enabled.  Use 'S' key to enable !\n");
  3964.                     if(logindi)
  3965.                         fprintf(lpp,
  3966.                         "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m SELECT-MODE not enabled.  Use 'S' key to enable !\n");
  3967.                     error_indi=TRUE;
  3968.                 }
  3969.                 goto Goon;
  3970.               }
  3971.  
  3972.  
  3973.               if(io_buff[0]=='K' && imax>1)
  3974.               {
  3975.                 error_indi=FALSE;
  3976.                 if(susy_flag)
  3977.                 {
  3978.                     if(markpr>1)
  3979.                     {
  3980.                         reference=FALSE;
  3981.                         refresh_flag=FALSE;
  3982.                         error_indi=FALSE;
  3983.                         killer=TRUE;
  3984.                         gotoxy(1,23);
  3985.                         if(markpr==ownuid)
  3986.                         {
  3987.                             printf(
  3988.                             "\033[K\007\033[7;7m SYSMON: \033[0;0m Kill own process '%s' ?  \033[5;5m Are You quite sure [Y]es/[N]o  ? \033[0;0m \n",killnam);
  3989.                             if(logindi)
  3990.                                 fprintf(lpp,
  3991.                                 "\033[K\007\033[7;7m SYSMON: \033[0;0m Kill own process '%s' ?  \033[5;5m Are You quite sure [Y]es/[N]o  ? \033[0;0m \n",killnam);
  3992.                                 suicid_flag=TRUE;
  3993.                         }
  3994.                         else
  3995.                         {
  3996.                             printf(
  3997.                             "\033[K\007\033[7;7m SYSMON: \033[0;0m Kill process '%s' ?  \033[5;5m Are You sure [Y]es/[N]o  ? \033[0;0m \n",killnam);
  3998.                             if(logindi)
  3999.                                 fprintf(lpp,
  4000.                                 "\033[K\007\033[7;7m SYSMON: \033[0;0m Kill process '%s' ?  \033[5;5m Are You sure [Y]es/[N]o  ? \033[0;0m \n",killnam);
  4001.                         }
  4002.                     }
  4003.                     else
  4004.                     {
  4005.                         gotoxy(1,23);
  4006.                         printf("%s\n",kernstr);
  4007.                         if(logindi)
  4008.                             fprintf(lpp,"%s\n",kernstr);
  4009.                         error_indi=TRUE;
  4010.                     }
  4011.                 }
  4012.                 else
  4013.                 {
  4014.                     gotoxy(1,23);
  4015.                     printf(
  4016.                     "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m Kill-option not enabled ! Use 'S' key to select process !\n");
  4017.                     if(logindi)
  4018.                         fprintf(lpp,
  4019.                         "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m Kill-option not enabled ! Use 'S' key to select process !\n");
  4020.                     error_indi=TRUE;
  4021.                    }
  4022.                 goto Goon;
  4023.               }
  4024.                 
  4025.               if(io_buff[0]=='O' && imax>1)
  4026.               {
  4027.                 error_indi=FALSE;
  4028.                 if(susy_flag)
  4029.                 {
  4030.                     if(markpr>1)
  4031.                     {
  4032.                         reference=FALSE;
  4033.                         refresh_flag=FALSE;
  4034.                         error_indi=FALSE;
  4035.                         spr_flag=SUSPEND;
  4036.                         gotoxy(1,23);
  4037.                         if(markprior>0)
  4038.                         {
  4039.                             if(markpr!=ownuid)
  4040.                             {
  4041.                                 if(pid[ownuid-1]==markpr)
  4042.                                 {
  4043.                                     printf(
  4044.                                     "\033[K\007\033[7;7m\033[1;1m\033[5;5m WARNING: \033[0;0m Suspend your parent process '%s' ?  \033[5;5m Are You quite sure ? [Y/N] \033[0;0m \n",killnam);
  4045.                                     if(logindi)
  4046.                                         fprintf(lpp,
  4047.                                         "\033[K\007\033[7;7m\033[1;1m\033[5;5m WARNING: \033[0;0m Suspend your parent process '%s' ?  \033[5;5m Are You quite sure ? [Y/N] \033[0;0m \n",killnam);
  4048.                                     bell=ON;
  4049.                                 }
  4050.                                 else
  4051.                                 {
  4052.                                     printf(
  4053.                                     "\033[K\007\033[7;7m SYSMON: \033[0;0m Suspend process '%s' ?  \033[5;5m Are You sure ? [Y/N] \033[0;0m \n",killnam);
  4054.                                     if(logindi)
  4055.                                         fprintf(lpp,
  4056.                                         "\033[K\007\033[7;7m SYSMON: \033[0;0m Suspend process '%s' ?  \033[5;5m Are You sure ? [Y/N] \033[0;0m \n",killnam);
  4057.                                 }
  4058.                             }
  4059.                             else
  4060.                             {        
  4061.                                 printf(
  4062.                                 "\033[K\007\033[7;7m\033[1;1m\033[5;5m WARNING: \033[0;0m Suspend your own process '%s' ?  \033[5;5m Are You quite sure ? [Y/N] \033[0;0m \n",killnam);
  4063.                                 if(logindi)
  4064.                                     fprintf(lpp,
  4065.                                     "\033[K\007\033[7;7m\033[1;1m\033[5;5m WARNING: \033[0;0m Suspend your own process '%s' ?  \033[5;5m Are You quite sure ? [Y/N] \033[0;0m \n",killnam);
  4066.                                 bell=ON;
  4067.                                 suicid_flag=TRUE;
  4068.                             }
  4069.                         }
  4070.                         else
  4071.                         {
  4072.                             printf(
  4073.                             "\033[K\007\033[7;7m SYSMON: \033[0;0m Enable process '%s' ?  \033[5;5m Are You sure ? [Y/N] \033[0;0m \n",killnam);
  4074.                             if(logindi)
  4075.                                 fprintf(lpp,
  4076.                                 "\033[K\007\033[7;7m SYSMON: \033[0;0m Enable process '%s' ?  \033[5;5m Are You sure ? [Y/N] \033[0;0m \n",killnam);
  4077.                         }
  4078.                      }
  4079.                     else
  4080.                     {
  4081.                        gotoxy(1,23);
  4082.                         printf("%s\n",kernstr);
  4083.                         if(logindi)
  4084.                             fprintf(lpp,"%s\n",kernstr);
  4085.                         error_indi=TRUE;
  4086.                     }
  4087.                 }
  4088.                 else
  4089.                 {
  4090.                     gotoxy(1,23);
  4091.                     printf(
  4092.                     "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m Suspend-option not enabled ! Use 'S' key to select process !\n");
  4093.                     if(logindi)
  4094.                         fprintf(lpp,
  4095.                         "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m Suspend-option not enabled ! Use 'S' key to select process !\n");
  4096.                     error_indi=TRUE;
  4097.                    }
  4098.                 goto Goon;
  4099.               }
  4100.  
  4101.               if(io_buff[0]=='T' && imax>1)
  4102.               {
  4103.                 error_indi=FALSE;
  4104.                 if(susy_flag)
  4105.                 {
  4106.                     gotoxy(1,23);
  4107.                     cursoroff();
  4108.                     reference=FALSE;
  4109.                     refresh_flag=FALSE;
  4110.                     error_indi=FALSE;
  4111.  
  4112.                     if(ownuid==markpr && prillow==FALSE)    /* if selected process is not the own ! */
  4113.                     {
  4114.                         gotoxy(1,23);
  4115.                         printf(
  4116.                         "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m You can't change priority from this source !\n");
  4117.                         if(logindi)
  4118.                             fprintf(lpp,
  4119.                             "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m You can't change priority from this source !\n");
  4120.                         error_indi=TRUE;
  4121.                     }
  4122.                     else
  4123.                     {
  4124.                         ret_disp=100;
  4125.                         newprior=prior[startc+actualcount];
  4126.  
  4127.                         gotoxy(1,23);
  4128.                         printf(
  4129.                         "\033[K\007\033[7;7m SYSMON: \033[0;0m ID: %03d %s \n"
  4130.                         ,markpr,killnam);
  4131.                         if(logindi)
  4132.                             fprintf(lpp,
  4133.                             "\033[K\007\033[7;7m SYSMON: \033[0;0m ID: %03d %s \n"
  4134.                             ,markpr,killnam);
  4135.                         gotoxy(35,23);
  4136.                         printf("priority: %6d Change [+/-] Set with [CR]\n",
  4137.                         newprior);
  4138.                         if(logindi)
  4139.                             fprintf(lpp,"priority: %6d Change [+/-] Set with [CR]\n",
  4140.                             newprior);
  4141.                     io_buff[0]=0;
  4142.                         dc=0;
  4143.  
  4144.                         for(;;)
  4145.                         {
  4146.                         ptaste=_gs_rdy(0);
  4147.                               if(ptaste>0)
  4148.                               {
  4149.                                 read(0,ptastbuff,ptaste);
  4150.                            
  4151.                                 if(ptastbuff[0]==13)
  4152.                                     break;
  4153.                                 else
  4154.                                 {
  4155.                                     switch(ptastbuff[0])
  4156.                                     {
  4157.                                         case '+':
  4158.                                         if((newprior+delta) <=65535)
  4159.                                             newprior+=delta;
  4160.                                         else
  4161.                                         {
  4162.                                             if(newprior<65535)
  4163.                                                 newprior++;
  4164.                                         }
  4165.                                         break;
  4166.  
  4167.                                         case '-':
  4168.                                         if((newprior-delta) >=0)
  4169.                                             newprior-=delta;
  4170.                                         else
  4171.                                         {
  4172.                                             if(newprior>0)
  4173.                                                 newprior--;
  4174.                                         }
  4175.                                         break;
  4176.                                     }
  4177.                                 }
  4178.  
  4179.                             gotoxy(45,23);
  4180.                                 printf("%6d\n",newprior);
  4181.                                 if(logindi)
  4182.                                     fprintf(lpp,"%6d\n",newprior);
  4183.  
  4184.                                 if(delta<1000)
  4185.                                     delta*=10;
  4186.                                 dc=0;
  4187.                             }                    
  4188.                           else
  4189.                             {
  4190.                                 tsleep(5);
  4191.                                 if(dc<10)
  4192.                                     dc++;
  4193.                                 else
  4194.                                     delta=1;
  4195.                             }
  4196.                         }
  4197.  
  4198.                         gotoxy(1,23);
  4199.                         printf(
  4200.                         "\033[K\007\033[7;7m SYSMON: \033[0;0m modify priority of process '%s' ? \033[7;7m\033[5;5m [Y]es/[N]o  ? \033[0;0m \n",killnam);
  4201.                         if(logindi)
  4202.                             fprintf(lpp,
  4203.                             "\033[K\007\033[7;7m SYSMON: \033[0;0m modify priority of process '%s' ? \033[7;7m\033[5;5m [Y]es/[N]o  ? \033[0;0m \n",killnam);
  4204.                         spr_flag=TRUE;
  4205.                     }
  4206.                 }
  4207.                 else
  4208.                 {
  4209.                     gotoxy(1,23);
  4210.                     printf(
  4211.                     "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m Priority-option not enabled ! Use 'S' key to select process !\n");
  4212.                     if(logindi)
  4213.                         fprintf(lpp,
  4214.                         "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m Priority-option not enabled ! Use 'S' key to select process !\n");
  4215.                     error_indi=TRUE;
  4216.                    }
  4217.                 if(mode_flag==1)
  4218.                 {
  4219.                     gotoxy(1,23);
  4220.                     cursoron();
  4221.                 }
  4222.                 goto Goon;
  4223.               }    
  4224.  
  4225.               if(io_buff[0]=='Z')
  4226.             {
  4227.                 if(privileg)
  4228.                 {
  4229.                     if(lpp)
  4230.                     {
  4231.                             if(logindi)        /* log switched on ! */
  4232.                             {
  4233.                                 logindi=FALSE;
  4234.                                 gotoxy(1,23);
  4235.                             printf(
  4236.                                 "\033[K\007\033[7;7m\033[5;5m SYSMON: \033[0;0m Display isn't longer logged in file: '%s' \n",
  4237.                                 logfilenam);
  4238.                                error_indi=TRUE;
  4239.                             }
  4240.                         else            /* log is switched off ! */
  4241.                             {
  4242.                                 gotoxy(1,23);
  4243.                             printf("\033[K\007\033[7;7m\033[5;5m SYSMON: \033[0;0m Display is logged in file: '%s' \n",
  4244.                                 logfilenam);
  4245.                                 logindi=TRUE;
  4246.                                 refresh_flag=TRUE;
  4247.                             }
  4248.                     }
  4249.                     else
  4250.                     {    
  4251.                         sprintf(logfilenam,"SYSMON_%06d.LOG",
  4252.                         std*10000+min*100+sec );
  4253.                         lpp=fopen(logfilenam,"a+");
  4254.                         logpath=open(logfilenam,1);
  4255.                         if(lpp && logpath!=-1)
  4256.                         {
  4257.                             gotoxy(1,23);
  4258.                             printf(
  4259.                             "\033[K\007\033[7;7m\033[5;5m SYSMON: \033[0;0m File: '%s' created, type 'Z' to log !\n",
  4260.                             logfilenam);
  4261.                             error_indi=TRUE;
  4262.                         }
  4263.                         else
  4264.                         {
  4265.                             gotoxy(1,23);
  4266.                             printf(
  4267.                             "\033[K\007\033[7;7m\033[5;5m SYSMON-ERROR: \033[0;0m File: '%s' can't be opened ! errno=%d\n",
  4268.                             logfilenam,errno);
  4269.                             error_indi=TRUE;
  4270.                         }
  4271.                     }
  4272.                 }
  4273.                 else
  4274.                 {
  4275.                     gotoxy(1,23);
  4276.                     printf(
  4277.                     "\033[K\007\033[7;7m\033[5;5m SYSMON: \033[0;0m No privilege for attempted operation ! errno=164\n");
  4278.                     error_indi=TRUE;
  4279.                 }
  4280.                 goto Goon;
  4281.             }
  4282.  
  4283.  
  4284.               if(io_buff[0]=='P')
  4285.             {
  4286.                 error_indi=FALSE;
  4287.                 cls();
  4288.                 if(prior_flag)
  4289.                     prior_flag=FALSE;
  4290.                 else
  4291.                     prior_flag=TRUE;
  4292.  
  4293.                 name_flag=FALSE;
  4294.                 susy_flag=FALSE;
  4295.                 lastcount=0;
  4296.                 mode_flag=0;
  4297.                 active_flag=0;
  4298.                 scc=1;
  4299.                 startc=0;
  4300.                    actualcount=0;
  4301.                 display_frame();
  4302.                 goto Goon;
  4303.             }
  4304.  
  4305.               if(io_buff[0]=='1')        /* SAVEUSERSETUP */
  4306.             {
  4307.                 retstr=saveusersetup();
  4308.                 if(retstr==FALSE)
  4309.                 {
  4310.                     gotoxy(1,23);
  4311.                     printf("\033[K\007\033[7;7m\033[5;5m SYSMON: \033[0;0m Usersetup successfully saved !\n");
  4312.                     if(logindi)
  4313.                         fprintf(lpp,
  4314.                     "\033[K\007\033[7;7m\033[5;5m SYSMON: \033[0;0m Usersetup successfully saved !\n");
  4315.                     error_indi=TRUE;
  4316.                 }
  4317.                 else
  4318.                 {
  4319.                     gotoxy(1,23);
  4320.                     printf("\033[K\007\033[7;7m\033[5;5m SYSMON: \033[0;0m Usersetup save failed !   errno=%d\n",retstr);
  4321.                     if(logindi)
  4322.                         fprintf(lpp,
  4323.                         "\033[K\007\033[7;7m\033[5;5m SYSMON: \033[0;0m Usersetup save failed !   errno=%d\n",retstr);
  4324.                     error_indi=TRUE;
  4325.                 }
  4326.                 goto Goon;
  4327.             }
  4328.  
  4329.               if(io_buff[0]=='2')        /* LOADUSERSETUP */
  4330.             {
  4331.                 retstr=loadusersetup();
  4332.                 if(retstr==FALSE)
  4333.                 {
  4334.                     gotoxy(1,23);
  4335.                     printf("\033[K\007\033[7;7m\033[5;5m SYSMON: \033[0;0m Usersetup successfully loaded !\n");
  4336.                     if(logindi)
  4337.                         fprintf(lpp,
  4338.                         "\033[K\007\033[7;7m\033[5;5m SYSMON: \033[0;0m Usersetup successfully loaded !\n");
  4339.                     sleep(2);
  4340.                     refresh_flag=TRUE;
  4341.                 }
  4342.                 else
  4343.                 {
  4344.                     gotoxy(1,23);
  4345.                     printf("\033[K\007\033[7;7m\033[5;5m SYSMON: \033[0;0m Usersetup load failed !   errno=%d\n",retstr);
  4346.                     if(logindi)
  4347.                         fprintf(lpp,
  4348.                         "\033[K\007\033[7;7m\033[5;5m SYSMON: \033[0;0m Usersetup load failed !   errno=%d\n",retstr);
  4349.                     error_indi=TRUE;
  4350.                 }
  4351.                 goto Goon;
  4352.             }
  4353.  
  4354.             if(mode_flag)
  4355.             {
  4356.                   if(io_buff[0]=='+')
  4357.                 {
  4358.                     if(actualcount<imax-15)
  4359.                       {    
  4360.                         error_indi=FALSE;
  4361.                         actualcount+=16;
  4362.                         under_title();
  4363.                         startc=0;
  4364.                         scc=fa+1;   /* +fb; */
  4365.                       }
  4366.                     else
  4367.                     {
  4368.                         gotoxy(1,23);
  4369.                         printf("%s\n",process_endstr);
  4370.                         if(logindi)
  4371.                             fprintf(lpp,"%s\n",process_endstr);
  4372.                         error_indi=TRUE;
  4373.                     }
  4374.                 }
  4375.             
  4376.                   if(io_buff[0]=='-')
  4377.                   {
  4378.                     if(actualcount>=16)
  4379.                     {
  4380.                         error_indi=FALSE;
  4381.                         actualcount-=16;
  4382.                         under_title();
  4383.                         scc=fa+fb;
  4384.                         startc=15;
  4385.                     }
  4386.                     else
  4387.                     {
  4388.                         actualcount=0;
  4389.                         gotoxy(1,23);
  4390.                         printf("%s\n",process_beginstr);
  4391.                         if(logindi)
  4392.                             fprintf(lpp,"%s\n",process_beginstr);
  4393.                         error_indi=TRUE;
  4394.                     }
  4395.                 }
  4396.               }
  4397.         }
  4398. Goon:
  4399.         get_ticktime();      /* how long is a tick lasting ? */
  4400.           icpt_flag=FALSE;  /* clear Icpt flag */
  4401.           tsleep(10);      /* sleep 100 ms     */
  4402.           _ss_ssig(0,DATAPRESENT);  /* send  signal on data ready */
  4403.     }
  4404.  
  4405.  
  4406.     if(refresh_flag==TRUE && !killer && !spr_flag)
  4407.     {       
  4408.         get_ticktime();        /* how long is a tick lasting ? */
  4409.         cls();
  4410.         switch (mode_flag)
  4411.         {
  4412.             case 0:
  4413.                 display_frame();
  4414.             break;
  4415.             case 1:
  4416.                 display_dframe();
  4417.                 break;
  4418.         }
  4419.         refresh_flag=DONE;
  4420.     }
  4421.     else
  4422.         refresh_flag=FALSE;
  4423.  
  4424.  
  4425.     if(!icpt_flag)
  4426.     {
  4427.         if(!selecta)
  4428.             display_time();
  4429.  
  4430.         if(bell==ON)
  4431.         {
  4432.             printf("\007");
  4433.             if(logindi)
  4434.                 fprintf(lpp,"\007");
  4435.         }
  4436.  
  4437.         switch (mode_flag)
  4438.         {
  4439.             case 0:
  4440.                 display_procs();
  4441.             break;
  4442.             case 1:
  4443.                 display_data();
  4444.                 break;
  4445.         }
  4446.         selecta=FALSE;    
  4447.  
  4448.         if(privileg && !killer && !spr_flag)
  4449.         {
  4450.             login_new=check_login();    /* are there any logins ??? */
  4451.             if(login_old && !login_new)
  4452.                 error_indi=TRUE;
  4453.             login_old=login_new;            
  4454.         }
  4455.  
  4456.     if(error_indi)
  4457.           {
  4458.             switch(mode_flag)
  4459.             {
  4460.                 case 0:
  4461.                     clearcondi=2;
  4462.                     break;
  4463.                 case 1:
  4464.                     clearcondi=1;
  4465.                     break;
  4466.             }
  4467.             if(delay>=10)
  4468.                 clearcondi=0;            
  4469.  
  4470.             if(ret_disp>=clearcondi)
  4471.             {
  4472.                 if(error_indi==TRISTATE)
  4473.                     refresh_flag=TRUE;
  4474.                 else
  4475.                 {
  4476.                     switch (mode_flag)
  4477.                     {
  4478.                         case 0:
  4479.                             gotoxy(1,23);
  4480.                             if(reference)
  4481.                             {        
  4482.                                 gotoxy(1,23);
  4483.                                 printf(
  4484.                                 "\033[K%s\n",referstr);
  4485.                                 if(logindi)
  4486.                                     fprintf(lpp,
  4487.                                     "\033[K%s\n",referstr);
  4488.                             }
  4489.                             else
  4490.                             {
  4491.                                 gotoxy(1,23);
  4492.                                 printf("\033[K\n");
  4493.                                 if(logindi)
  4494.                                     fprintf(lpp,"\033[K\n");
  4495.                                 gotoxy(37,23);
  4496.                                 printf("%s\n",prozent);
  4497.                                 if(logindi)
  4498.                                     fprintf(lpp,"%s\n",prozent);
  4499.                             }
  4500.                             break;
  4501.                         case 1:
  4502.                             under_title();
  4503.                             break;
  4504.                     }
  4505.                 }
  4506.                 ret_disp=0;
  4507.                 error_indi=FALSE;
  4508.             }
  4509.             ret_disp++;
  4510.         }
  4511.  
  4512.         if(killit)  /* process marked to kill ! */
  4513.         {
  4514.             gotoxy(1,23);
  4515.             fflush(stdout);
  4516.             tsleep(20);
  4517.             kha=kill_pr(mark_proc);
  4518.            if(!kha)
  4519.             {
  4520.                 sleep(1); 
  4521.                 gotoxy(1,23);
  4522.                 printf(
  4523.                 "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m Unkown process: %d has been killed  !\n",mark_proc);
  4524.                 if(logindi)
  4525.                     fprintf(lpp,
  4526.                     "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m Unkown process: %d has been killed  !\n",mark_proc);
  4527.                 tsleep(50);
  4528.             }
  4529.             else
  4530.             {
  4531.                 gotoxy(1,23);
  4532.                 printf(
  4533.                 "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m Unkown process: %d can't be killed  ! errno=%d\n",mark_proc,kha);
  4534.                 if(logindi)
  4535.                     fprintf(lpp,
  4536.                     "\033[K\007\033[7;7m\033[1;1m\033[5;5m SYSMON: \033[0;0m Unkown process: %d can't be killed  ! errno=%d\n",mark_proc,kha);
  4537.                 tsleep(50);
  4538.             }
  4539.             mark_proc=0;
  4540.             killit=FALSE;
  4541.             refresh_flag=TRUE;
  4542.         }    
  4543.     }
  4544.   }
  4545. }
  4546. /*---------------------------------------------------------------------------*/
  4547. /* name: KILL_PR                                                             */
  4548. /* function: kill process with PID                                           */
  4549. /* by: FRS                                                                   */
  4550. /* Date: 02/02/89                                                            */
  4551. /*---------------------------------------------------------------------------*/
  4552. kill_pr(num)
  4553. register int num;
  4554. {
  4555.     register int khandle;
  4556.  
  4557.     khandle=kill(num,SIGKILL);
  4558.     if(khandle==-1)
  4559.         return(errno);
  4560.     khandle=wait(0);
  4561.     return(0);
  4562. }
  4563. /*-----------------------------------------------------------------------*/
  4564. inkey(inmode,textpoi)
  4565. register int inmode;
  4566. register char *textpoi;
  4567. {
  4568.    register int taste;
  4569.    int tastcount=0, ref; 
  4570.    char tastbuff[255];
  4571.    int jtime, jdate,jtick;
  4572.    short jday;
  4573.  
  4574.  
  4575.    gotoxy(1,23); 
  4576.    printf("%s ",textpoi);
  4577.    if(logindi) 
  4578.     fprintf(lpp,"%s ",textpoi);
  4579.    gotoxy(1,22);
  4580.    printf("\n"); 
  4581.    if(logindi) 
  4582.     fprintf(lpp,"\n"); 
  4583.  
  4584.    _sysdate(0,&jtime,&jdate,&jday,&jtick);
  4585.    _julian(&jtime,&jdate);
  4586.    ref=86400*jdate+(86400-jtime);
  4587.  
  4588.    for(;;)
  4589.    {
  4590.       taste=_gs_rdy(0);
  4591.       if(taste>0)
  4592.       {
  4593.         read(0,tastbuff,taste);
  4594.         tastbuff[0]=toupper(tastbuff[0]);
  4595.         
  4596.          if(tastbuff[0]=='Y' || tastbuff[0]=='Q')
  4597.             return(TRUE);
  4598.         else
  4599.             return(FALSE);
  4600.         break;
  4601.       }
  4602.  
  4603.       _sysdate(0,&jtime,&jdate,&jday,&jtick);
  4604.       _julian(&jtime,&jdate);
  4605.       tastcount=ref-(86400*jdate+(86400-jtime));
  4606.       tsleep(10);
  4607.  
  4608.       if(inmode)    /* only if inmode !=0 */
  4609.       {    
  4610.           if(tastcount>inmode) 
  4611.             return(TIMEOUT);
  4612.       }    
  4613.    }
  4614.    return(FALSE);
  4615. }
  4616. /*-----------------------------------------------------------------------*/
  4617. helpuser()
  4618. {
  4619.   effect();  
  4620.   cls();
  4621.   printf("Syntax: sysmon [<opt>] \n");
  4622.   printf("Version: %s %s\n",versi,LAST_EDITION_DATE);
  4623.   printf("Function: show active tasks and cpu time consumption \n");  
  4624.   printf("Options: \n");
  4625.   printf("     -a      select alphanumeric mode \n");
  4626.   printf("     -b      select alphanumeric mode [extended]\n");
  4627.   printf("     -d      get default device from 'init'-module \n");
  4628.   printf("     -e      select alphanumeric mode [module information]\n");
  4629.   printf("     -j      enable max-hold function [dislay maximum cputime used]\n");
  4630.   printf("     -m      mark processes using more than 75 %% cpu time  [graphic mode]\n");
  4631.   printf("     -p      show process priority instead of group & user [graphic mode]\n");
  4632.   printf("     -q      disable priority rising during work of sysmon [only at /term]\n");
  4633.   printf("     -r      switch QUICK-REFERENCE on\n");
  4634.   printf("     -t=s    get value for scan-time [seconds]\n");
  4635.   printf("     -u      select user mode (display only user processes) \n");
  4636.   printf("     -v      show program version and explanation\n");
  4637.   printf("     -w      enable WATCH-mode [kill unkown user processes]\n");
  4638.   printf("     -?      show this explanation \n");
  4639.   printf("NOTE:    While the program is running you can switch from NAME - mode \n");
  4640.   printf("         to DATA - mode by typing the 'N' - key. It's also possible to \n");
  4641.   printf("         switch to ALFA - mode by typing 'A' - key or to switch to \n");
  4642.   printf("         GRAFIC - mode by typing the 'G' - key ! \n");
  4643.   if(logindi)
  4644.   {  
  4645.     fprintf(lpp,"Syntax: sysmon [<opt>] \n");
  4646.     fprintf(lpp,"Version: %s %s\n",versi,LAST_EDITION_DATE);
  4647.     fprintf(lpp,"Function: show active tasks and cpu time consumption \n");  
  4648.     fprintf(lpp,"Options: \n");
  4649.     fprintf(lpp,"     -a      select alphanumeric mode \n");
  4650.     fprintf(lpp,"     -b      select alphanumeric mode [extended]\n");
  4651.     fprintf(lpp,"     -d      get default device from 'init'-module \n");
  4652.     fprintf(lpp,"     -e      select alphanumeric mode [module information]\n");
  4653.     fprintf(lpp,"     -j      enable max-hold function [dislay maximum cputime used]\n");
  4654.     fprintf(lpp,"     -m      mark processes using more than 75 %% cpu time  [graphic mode]\n");
  4655.     fprintf(lpp,"     -p      show process priority instead of group & user [graphic mode]\n");
  4656.     fprintf(lpp,"     -q      disable priority rising during work of sysmon [only at /term]\n");
  4657.     fprintf(lpp,"     -r      switch QUICK-REFERENCE on\n");
  4658.     fprintf(lpp,"     -t=s    get value for scan-time [seconds]\n");
  4659.     fprintf(lpp,"     -u      select user mode (display only user processes) \n");
  4660.     fprintf(lpp,"     -v      show program version and explanation\n");
  4661.     fprintf(lpp,"     -w      enable WATCH-mode [kill unkown user processes]\n");
  4662.     fprintf(lpp,"     -?      show this explanation \n");
  4663.     fprintf(lpp,"NOTE:    While the program is running you can switch from NAME - mode \n");
  4664.     fprintf(lpp,"         to DATA - mode by typing the 'N' - key. It's also possible to \n");
  4665.     fprintf(lpp,"         switch to ALFA - mode by typing 'A' - key or to switch to \n");
  4666.     fprintf(lpp,"         GRAFIC - mode by typing the 'G' - key ! \n");
  4667.   }
  4668. }
  4669. /*---------------------------------------------------------------------------*/
  4670. show_version()
  4671. {
  4672.   int retstr;
  4673.   effect();  
  4674.   cls();
  4675.   printf ("\033(0");
  4676.   printf ("%s",hdr);
  4677.   printf ("\033(B\n");
  4678.   if(logindi)
  4679.   {  
  4680.     fprintf (lpp,"\033(0");
  4681.     fprintf (lpp,"%s",hdr);
  4682.     fprintf (lpp,"\033(B\n");
  4683.   }
  4684.   gotoxy(1,22);
  4685.   printf ("\033(0");
  4686.   printf ("%s",hdr);
  4687.   printf ("\033(B\n");
  4688.   if(logindi)
  4689.   {  
  4690.     fprintf (lpp,"\033(0");
  4691.     fprintf (lpp,"%s",hdr);
  4692.     fprintf (lpp,"\033(B\n");
  4693.   }
  4694.   gotoxy(1,2);
  4695.   printf("\033[7;7m SYSMON %s \033[0;0m by W.Ott & F.R.Schmitt MPI Kernphysik Heidelberg\n",versi);
  4696.   printf("We hope this is a very usefull tool for monitoring your system.\n"); 
  4697.   printf("For the usage of this program a VT100 [or better a VT220] terminal has to be\n"); 
  4698.   printf("connected to your OS9-System ! Baudrates > 9600 are usefull to get a very fast\n");
  4699.   printf("screenupdate. \n");
  4700.   printf("While the program is running, you can switch to the following modes:\n\n");
  4701.   printf("                                   A  => ALPHA MODE\n");
  4702.   printf("                                   B  => ALPHA MODE [extended]\n");
  4703.   printf("                                   C  => CLEAR CPU %% BEFORE UPDATE [ON/OFF]\n");
  4704.   printf("                                   D  => SET TIME DELAY\n");
  4705.   printf("                                   E  => MODUL INFORMATION\n");
  4706.   printf("                                   F  => FORK SHELL/ZSH\n");
  4707.   printf("                                   G  => GRAPHIC MODE\n");
  4708.   printf("                                   H  => ONLINE HELP\n");
  4709.   printf("                                   I  => READ PASSWORDFILE\n");
  4710.   printf("                                   J  => HOLD MAXIMUM CPUTIME CONSUPTION\n");
  4711.   printf("                                   K  => KILL SELECTED PROCESS\n");
  4712.   printf("                                   L  => ENABLE ALL SUSPENDED PROCESSES\n");
  4713.   if(logindi)
  4714.   {
  4715.     fprintf(lpp,"\033[7;7m SYSMON %s \033[0;0m by W.Ott & F.R.Schmitt MPI Kernphysik Heidelberg\n",versi);
  4716.     fprintf(lpp,"We hope this is a very usefull tool for monitoring your system.\n"); 
  4717.     fprintf(lpp,"For the usage of this program a VT100 [or better a VT220] terminal has to be\n"); 
  4718.     fprintf(lpp,"connected to your OS9-System ! Baudrates > 9600 are usefull to get a very fast\n");
  4719.     fprintf(lpp,"screenupdate. \n");
  4720.     fprintf(lpp,"While the program is running, you can switch to the following modes:\n\n");
  4721.     fprintf(lpp,"                                   A  => ALPHA MODE\n");
  4722.     fprintf(lpp,"                                   B  => ALPHA MODE [extended]\n");
  4723.     fprintf(lpp,"                                   C  => CLEAR CPU %% BEFORE UPDATE [ON/OFF]\n");
  4724.     fprintf(lpp,"                                   D  => SET TIME DELAY\n");
  4725.     fprintf(lpp,"                                   E  => MODUL INFORMATION\n");
  4726.     fprintf(lpp,"                                   F  => FORK SHELL/ZSH\n");
  4727.     fprintf(lpp,"                                   G  => GRAPHIC MODE\n");
  4728.     fprintf(lpp,"                                   H  => ONLINE HELP\n");
  4729.     fprintf(lpp,"                                   I  => READ PASSWORDFILE\n");
  4730.     fprintf(lpp,"                                   J  => HOLD MAXIMUM CPUTIME CONSUPTION\n");
  4731.     fprintf(lpp,"                                   K  => KILL SELECTED PROCESS\n");
  4732.     fprintf(lpp,"                                   L  => ENABLE ALL SUSPENDED PROCESSES\n");
  4733.   }
  4734.   retstr=inkey(0,"\033[7;7m Press any key for more or 'Q' to return. \033[0;0m");
  4735.   if(retstr)
  4736.     return(1);
  4737.   effect();
  4738.   cls();
  4739.   printf ("\033(0");
  4740.   printf ("%s",hdr);
  4741.   printf ("\033(B\n");
  4742.   if(logindi)
  4743.   {  
  4744.     fprintf (lpp,"\033(0");
  4745.     fprintf (lpp,"%s",hdr);
  4746.     fprintf (lpp,"\033(B\n");
  4747.   }
  4748.  
  4749.   gotoxy(1,22);  
  4750.   printf ("\033(0");
  4751.   printf ("%s",hdr);
  4752.   printf ("\033(B\n");
  4753.   if(logindi)
  4754.   {  
  4755.     fprintf (lpp,"\033(0");
  4756.     fprintf (lpp,"%s",hdr);
  4757.     fprintf (lpp,"\033(B\n");
  4758.   }
  4759.   gotoxy(1,2);  
  4760.   printf("                                   M  => MARK PROCESSES > 75 %% CPU\n");
  4761.   printf("                                   N  => NAME  MODE\n");
  4762.   printf("                                   O  => SUSPEND/ENABLE PROCESS\n");
  4763.   printf("                                   P  => PRIORITY display [ON/OFF]\n");
  4764.   printf("                                   Q  => QUIT SYSMON\n"); 
  4765.   printf("                                   R  => QUICK REFERENCE ON/OFF\n");
  4766.   printf("                                   S  => SELECT-MODE [ON/OFF]\n");
  4767.   printf("                                   T  => SET PROCESS PRIORITY\n");
  4768.   printf("                                   U  => ONLY DISPLAY USERPROCESSES\n");
  4769.   printf("                                   V  => SHOW IO PATHES\n");
  4770.   printf("                                   W  => KILL UNKOWN USER PROCESSES\n");
  4771.   printf("                                   X  => RESET CPU\n");
  4772.   printf("                                   Z  => ENABLE FILE LOGING\n");
  4773.   printf("                                   1  => SAVE USERSETTINGS\n");
  4774.   printf("                                   2  => LOAD USERSETTINGS\n\n");
  4775.   printf("       CURSOR RIGHT/LEFT  or   + / -  => NEXT 16 PROCESSES\n");
  4776.   printf("       CURSOR UP/DOWN     or   < / >  => SELECT PROCESS [SELECT MODE]\n\n");
  4777.   if(logindi)
  4778.   {
  4779.     fprintf(lpp,"                                   M  => MARK PROCESSES > 75 %% CPU\n");
  4780.     fprintf(lpp,"                                   N  => NAME  MODE\n");
  4781.     fprintf(lpp,"                                   O  => SUSPEND/ENABLE PROCESS\n");
  4782.     fprintf(lpp,"                                   P  => PRIORITY display [ON/OFF]\n");
  4783.     fprintf(lpp,"                                   Q  => QUIT SYSMON\n"); 
  4784.     fprintf(lpp,"                                   R  => QUICK REFERENCE ON/OFF\n");
  4785.     fprintf(lpp,"                                   S  => SELECT-MODE [ON/OFF]\n");
  4786.     fprintf(lpp,"                                   T  => SET PROCESS PRIORITY\n");
  4787.     fprintf(lpp,"                                   U  => ONLY DISPLAY USERPROCESSES\n");
  4788.     fprintf(lpp,"                                   V  => SHOW IO PATHES\n");
  4789.     fprintf(lpp,"                                   W  => KILL UNKOWN USER PROCESSES\n");
  4790.     fprintf(lpp,"                                   X  => RESET CPU\n");
  4791.     fprintf(lpp,"                                   Z  => ENABLE FILE LOGING\n");
  4792.     fprintf(lpp,"                                   1  => SAVE USERSETTINGS\n");
  4793.     fprintf(lpp,"                                   2  => LOAD USERSETTINGS\n\n");
  4794.     fprintf(lpp,"       CURSOR RIGHT/LEFT  or   + / -  => NEXT 16 PROCESSES\n");
  4795.     fprintf(lpp,"       CURSOR UP/DOWN     or   < / >  => SELECT PROCESS [SELECT MODE]\n\n");
  4796.   }  
  4797.   retstr=inkey(0,"\033[7;7m Press any key for more or 'Q' for to return. \033[0;0m");
  4798.   if(retstr)
  4799.     return(1);
  4800.   effect();
  4801.   cls();  
  4802.   printf ("\033(0");
  4803.   printf ("%s",hdr);
  4804.   printf ("\033(B\n");
  4805.   if(logindi)
  4806.   {  
  4807.     fprintf (lpp,"\033(0");
  4808.     fprintf (lpp,"%s",hdr);
  4809.     fprintf (lpp,"\033(B\n");
  4810.   }
  4811.   gotoxy(1,22);  
  4812.   printf ("\033(0");
  4813.   printf ("%s",hdr);
  4814.   printf ("\033(B\n");
  4815.   if(logindi)
  4816.   {  
  4817.     fprintf (lpp,"\033(0");
  4818.     fprintf (lpp,"%s",hdr);
  4819.     fprintf (lpp,"\033(B\n");
  4820.   }
  4821.   gotoxy(1,2);  
  4822.  
  4823.   printf("Send a mail if you are interested on the latest version !\n");  
  4824.   printf("Also send bug-reports, or any suggestions to improve this program, to:\n\n");
  4825.   printf("Frank Richard Schmitt\n");
  4826.   printf("MPI Kernphysik Heidelberg\n");
  4827.   printf("P.O.-BOX 103980\n");
  4828.   printf("D-6900 Heidelberg\n");
  4829.   printf("West Germany\n\n");
  4830.   printf("or phone: (06221)/516284 or 516515 \n");
  4831.   printf("BITNET: jnet%%\"SCHMITT@DHDMPI5H\"\n");
  4832.   printf("BTX: *0622454879#\n");
  4833.   printf("PACKET RADIO: DF3UM @DB0GV.DL.EU\n\n");
  4834.   if(logindi)
  4835.   {
  4836.     fprintf(lpp,"Send a mail if you are interested on the latest version !\n");  
  4837.     fprintf(lpp,"Also send bug-reports, or any suggestions to improve this program, to:\n\n");
  4838.     fprintf(lpp,"Frank Richard Schmitt\n");
  4839.     fprintf(lpp,"MPI Kernphysik Heidelberg\n");
  4840.     fprintf(lpp,"P.O.-BOX 103980\n");
  4841.     fprintf(lpp,"D-6900 Heidelberg\n");
  4842.     fprintf(lpp,"West Germany\n\n");
  4843.     fprintf(lpp,"or phone: (06221)/516284 or 516515 \n");
  4844.     fprintf(lpp,"BITNET: jnet%%\"SCHMITT@DHDMPI5H\"\n");
  4845.     fprintf(lpp,"BTX: *0622454879#\n");
  4846.     fprintf(lpp,"PACKET RADIO: DF3UM @DB0GV.DL.EU\n\n");
  4847.   }
  4848.   return(0);  
  4849. }
  4850. /*---------------------------------------------------------------------------*/
  4851. /* name: CHECK_IT                                                            */
  4852. /* function: check first if program is running under system                  */
  4853. /* by: FRS                                                                   */
  4854. /* Date: 08/10/91                                                            */
  4855. /*---------------------------------------------------------------------------*/
  4856. check_it()
  4857. {
  4858.    register int i, bytes;
  4859.  
  4860.    unsigned short id,pid,group,user;
  4861.    unsigned short proctab[sizeof(struct pdsc)];
  4862.    register struct pdsc *pr;
  4863.  
  4864.    ownuid=getpid();   /* get our own process id */
  4865.    if(ownuid==-1)
  4866.    {    
  4867.     gotoxy(1,23);    
  4868.     printf("\033[K\007\033[7;7m SYSMON-ERROR: \033[0;0m Can't get own process_uid : ",ownuid);
  4869.     if(logindi)
  4870.         fprintf(lpp,"\033[K\007\033[7;7m SYSMON-ERROR: \033[0;0m Can't get own process_uid : ",ownuid);
  4871.     switch_ctrl(RESTORE);
  4872.     exit(errno);
  4873.    }
  4874.  
  4875.    pr = (struct pdsc *)proctab;
  4876.  
  4877.    bytes = _get_process_desc(ownuid,sizeof(struct pdsc),pr);
  4878.    if(bytes != -1)
  4879.    {      
  4880.       id=bytes;
  4881.       group=oldgrp=pr->_group;
  4882.       user=oldus=pr->_user;
  4883.       orginatprior=pr->_prior;
  4884.    
  4885.       if(strncmp(portnam,"TERM",4)==0)  /* only at /TERM                   */
  4886.         ownprior=orginatprior;            /* priority => startuppriority !   */
  4887.       else
  4888.       {
  4889.         prillow=FALSE;        /* don't allow priority rising during activity !*/
  4890.         ownprior=128;        /* default priority for OS9/68k ! */
  4891.       }
  4892.  
  4893.       if(strncmp(portnam,"TERM",4)!=0 && user!=0)   /* only at /TERM      */
  4894.     reset_flag=FALSE;                           /* reset is allowed ! */
  4895.  
  4896.       if(!group && user!=9)
  4897.       {
  4898.         privileg=TRUE;
  4899.         mindelay=1;
  4900.       }
  4901.       else
  4902.       {
  4903.         if(group)
  4904.         {
  4905.             mindelay=delay+2;
  4906.             delay+=2;
  4907.         }
  4908.         privileg=FALSE;
  4909.       }
  4910.    }
  4911.    else
  4912.    {
  4913.       gotoxy(1,23);
  4914.       printf("\007\033[7;7m SYSMON-ERROR: \033[0;0m Can't get processdata for own process !\n");
  4915.       if(logindi)    
  4916.           fprintf(lpp,"\007\033[7;7m SYSMON-ERROR: \033[0;0m Can't get processdata for own process !\n");
  4917.       switch_ctrl(RESTORE);
  4918.       exit(errno);
  4919.    }
  4920. }
  4921. /*---------------------------------------------------------------------------*/
  4922. cursoroff()
  4923. {
  4924.     printf("\033[?25l\n");
  4925.     if(logindi)
  4926.         fprintf(lpp,"\033[?25l\n");
  4927. }
  4928. /*---------------------------------------------------------------------------*/
  4929. cursoron()
  4930. {
  4931.     printf("\033[?25h\n");
  4932.     if(logindi)
  4933.         fprintf(lpp,"\033[?25h\n");
  4934. }
  4935. /*---------------------------------------------------------------------------*/
  4936. termcheck()
  4937. {
  4938.     register char *pterminal, *puser;  
  4939.     register int i;
  4940.     char terminal[100];
  4941.     char user[100];
  4942.  
  4943.  
  4944.     pterminal=(char *) getenv("TERM");
  4945.     if(pterminal!=0)
  4946.     {
  4947.         sprintf(terminal,"%s",pterminal);
  4948.         uppercase(terminal);
  4949.  
  4950.         for(i=0;i<=5;i++)
  4951.         {
  4952.             if(strcmp(terminal,termtype[i])==0)
  4953.                 return(0);
  4954.         }
  4955.         printf("\nSYSMON: '%s' terminal not supported !\n",terminal);
  4956.         printf("        Only the following TERMINALS are supported:\n        ");
  4957.         for(i=0;i<=5;i++)
  4958.             printf("%s  ",termtype[i]);
  4959.         printf("\n\n");
  4960.         if(strncmp(portnam,"PKS",3)==0)
  4961.             sleep(2);
  4962.         exit(0);
  4963.     }  
  4964.     else
  4965.     {
  4966.         puser=(char *) getenv("USER");
  4967.         if(puser!=0)
  4968.         {
  4969.             sprintf(user,"%s",puser);
  4970.             uppercase(user);
  4971.             if(strncmp("SYSMON",user,6)==0)
  4972.             {
  4973.                 cls();
  4974.                   gotoxy(1,23);
  4975.                 printf("\033[7;7m SYSMON: \033[0;0m Environment variable 'TERM' not set !  Assumming VT100-terminal !\n"); 
  4976.                 sleep(3);
  4977.                 return(0);
  4978.             }
  4979.             else
  4980.             {
  4981.                 printf("%s\n",termwarnstr);
  4982.                 if(strncmp(portnam,"PKS",3)==0)
  4983.                     sleep(2);
  4984.                 exit(errno);
  4985.             }
  4986.         }
  4987.         else
  4988.         {
  4989.             printf("%s\n",termwarnstr);
  4990.             if(strncmp(portnam,"PKS",3)==0)
  4991.                 sleep(2);
  4992.             exit(errno);
  4993.         }
  4994.     }
  4995. }
  4996. /*---------------------------------------------------------------------------*/
  4997. nodedefcreate()
  4998. {
  4999.     FILE *nodedef_f;
  5000.     int askret;
  5001.     char inkstr[100];
  5002.  
  5003.     cls();
  5004.     sprintf(inkstr,
  5005.     "\033[K\007\033[7;7m SYSMON: \033[0;0m File: '%s' doesn't exist !  Create it \033[1;1m\033[5;5m\033[7;7m[Y/N]\033[0;0m ?",nodedefnam);
  5006.     askret=inkey(30,inkstr);
  5007.     switch(askret)
  5008.     {
  5009.         case TRUE:
  5010.             gotoxy(1,23);
  5011.             printf("\033[K\033[7;7m SYSMON: \033[0;0m Please enter SYSTEM-NODENAME [max 10 char] : ");
  5012.             fflush(stdout);  
  5013.             if(rawinput(nodename)==0)                
  5014.                 return(FALSE);
  5015.  
  5016.             nodedef_f=fopen(nodedefnam,"w+");
  5017.             if(nodedef_f==0)
  5018.             {
  5019.                   gotoxy(1,23);
  5020.                 printf("\033[K\007\033[7;7m SYSMON-ERROR: \033[0;0m Creation of '%s' failed !   errno=%d\n",nodedefnam,errno); 
  5021.                 error_indi=TRUE;
  5022.                 return(FALSE);
  5023.             }
  5024.             else
  5025.             {
  5026.                 uppercase(nodename);
  5027.                 fprintf(nodedef_f,"%s\n",nodename);
  5028.                 fclose(nodedef_f);
  5029.                 return(TRUE);
  5030.             }
  5031.             break;
  5032.  
  5033.         case TIMEOUT:
  5034.             error_indi=TRUE;
  5035.             gotoxy(1,23);
  5036.             printf("%s",timeoutstr);
  5037.             if(logindi)
  5038.                 fprintf(lpp,"%s",timeoutstr);
  5039.             sleep(2);
  5040.             return(FALSE);
  5041.             break;
  5042.  
  5043.         default:
  5044.             error_indi=TRUE;
  5045.             ret_disp=100;
  5046.             gotoxy(1,23);
  5047.             printf("\033[K\n");
  5048.             if(logindi)
  5049.                  fprintf(lpp,"\033[K\n");
  5050.             return(FALSE);
  5051.             break;
  5052.     }
  5053. }
  5054. /*---------------------------------------------------------------------------*/
  5055. rawinput(input)
  5056. char *input;
  5057. {
  5058.     register int i, ref;
  5059.     register int index=0;
  5060.     int bytes;
  5061.     char *inpoi;
  5062.     char taste;
  5063.  
  5064.     int jtime, jdate,jtick;
  5065.     short jday;
  5066.  
  5067.     inpoi=input;
  5068.  
  5069.     _sysdate(0,&jtime,&jdate,&jday,&jtick);
  5070.     _julian(&jtime,&jdate);
  5071.     ref=86400*jdate+(86400-jtime);
  5072.  
  5073.     for(;;)
  5074.     {
  5075.           if(_gs_rdy(0)>0)
  5076.           {
  5077.             if(read(0,&taste,1)==-1)        /* read one byte ! */
  5078.                 break;
  5079.  
  5080.             if(icpt_flag)
  5081.             {
  5082.                 *input=0;
  5083.                 return(0);
  5084.             }
  5085.  
  5086.             if(taste==25)                 /* ^Y detected ! */
  5087.             {
  5088.                 *input=0;
  5089.                 return(0);
  5090.             }
  5091.  
  5092.             if(taste==26)                 /* ^Z detected ! */
  5093.             {
  5094.                 printf("\033[7;7m EXIT \033[0;0m \n");
  5095.                 return(0);
  5096.             }
  5097.  
  5098.             if(taste=='\n')         /* CR detected ! */
  5099.             {
  5100.                 printf("\n");
  5101.                 break;
  5102.             }
  5103.  
  5104.             if(taste==8 || taste==0x7f)        /* BACKSPACE ! */    
  5105.             {
  5106.                 if(index>0)
  5107.                 {
  5108.                     index--;
  5109.                     inpoi--;
  5110.                     *inpoi=0;
  5111.                        printf("\033[1D\033[1P");
  5112.                     fflush(stdout);
  5113.                 }
  5114.             }
  5115.             else
  5116.             {
  5117.                 if(index>=10)        /* max 10 characters allowed ! */
  5118.                     continue;
  5119.  
  5120.                 printf("%c",taste);
  5121.             fflush(stdout);
  5122.                 *inpoi=taste;
  5123.                 inpoi++;
  5124.                 *inpoi=0;
  5125.                 index++;
  5126.             }
  5127.             _sysdate(0,&jtime,&jdate,&jday,&jtick);
  5128.             _julian(&jtime,&jdate);
  5129.             ref=86400*jdate+(86400-jtime);
  5130.           }
  5131.         else
  5132.         {
  5133.             _sysdate(0,&jtime,&jdate,&jday,&jtick);
  5134.             _julian(&jtime,&jdate);
  5135.             i=ref-(86400*jdate+(86400-jtime));
  5136.             tsleep(5);
  5137.         }
  5138.  
  5139.         if(i>60)              /* ca. 60 seconds TIMEOUT ! */
  5140.         {
  5141.                 gotoxy(1,23);
  5142.                 printf("\033[K\007\033[7;7;m SYSMON: \033[0;0m Input timeout period expired !\n");
  5143.                 sleep(3);
  5144.                 return(0);
  5145.         }
  5146.     }
  5147.  
  5148.     if(index<=2)
  5149.         return(0);
  5150.     else
  5151.         return(TRUE);
  5152. }
  5153. /*---------------------------------------------------------------------------*/
  5154. loadusersetup()
  5155. {
  5156.     FILE *setupf;
  5157.     register int errvar;
  5158.     register char *userssup;
  5159.     char usershome[100];  
  5160.     unsigned char values[10];
  5161.  
  5162.     userssup=(char *) getenv("HOME");
  5163.     if(userssup!=0)
  5164.     {
  5165.         sprintf(usershome,"%s/.sysmon.init",userssup);
  5166.         setupf=fopen(usershome,"r");
  5167.         if(setupf!=0)
  5168.         {
  5169.              if(fread(values,1,4,setupf)!=4)
  5170.             {
  5171.                 errvar=errno;
  5172.                 fclose(setupf);
  5173.                 return(errvar);
  5174.             }
  5175.             fclose(setupf);
  5176.  
  5177.             mode_flag=(values[0] & 0x01);
  5178.             exmode=(values[1] & 0x03);
  5179.             susy_flag=(values[2] & 0x01);
  5180.             delay=values[3];
  5181.             if(delay>60)
  5182.                 delay=60;
  5183.             if(privileg==FALSE)
  5184.                 susy_flag=FALSE;
  5185.  
  5186.               if(strncmp(portnam,"PKS",3)==0)
  5187.               {    
  5188.                 if(delay<6)
  5189.                        delay=6;
  5190.                 stdout->_flag |=_UNBUF;
  5191.               }
  5192.             myolddelay=delay;
  5193.             return(FALSE);
  5194.         }
  5195.         else
  5196.             return(errno);
  5197.     }
  5198.     else
  5199.         return(errno);
  5200. }
  5201. /*---------------------------------------------------------------------------*/
  5202. saveusersetup()
  5203. {
  5204.     FILE *setupf;
  5205.     register int errvar;
  5206.     register char *userssup;
  5207.     char usershome[100];  
  5208.     unsigned char values[10];
  5209.  
  5210.     userssup=(char *) getenv("HOME");
  5211.     if(userssup!=0)
  5212.     {
  5213.         sprintf(usershome,"%s/.sysmon.init",userssup);
  5214.         setupf=fopen(usershome,"w+");
  5215.         if(setupf!=0)
  5216.         {
  5217.             if(privileg==FALSE)
  5218.                 susy_flag=FALSE;
  5219.             values[0]=mode_flag;
  5220.             values[1]=exmode;
  5221.             values[2]=susy_flag;
  5222.             values[3]=delay;
  5223.  
  5224.              if(fwrite(values,1,4,setupf)!=4)
  5225.             {
  5226.                 errvar=errno;
  5227.                 fclose(setupf);
  5228.                 return(errvar);
  5229.             }
  5230.             fclose(setupf);
  5231.             return(FALSE);
  5232.         }
  5233.         return(errno);
  5234.     }
  5235.     else
  5236.         return(errno);
  5237. }
  5238. /*===========================================================================*/
  5239. main(argc,argv,envir)
  5240. int argc;
  5241. char *argv[];
  5242. char *envir[];
  5243. {
  5244.   FILE *nodedef;
  5245.   char *cpoi, *ppoi;
  5246.   char *fmodpoi;  
  5247.   register int i;
  5248.  
  5249.   int cpyh=0;
  5250.   short Sysdev_offset;
  5251.   short *Sysdev_poi;  
  5252.   char abort=0;  
  5253.     
  5254.   environa=(char **) envir;  
  5255.  
  5256.  
  5257.  
  5258.  
  5259.   /* THIS SECTION WAS PROGRAMMED BY F.KOECK  DESOLATE SYSTEMS INC. (C) 1992 */
  5260.   for(i=0;i<ARG_ENV_NUM-1;i++)
  5261.   {
  5262.      if((argblk[i]=(char *) calloc(1,ARG_ENV_LEN))==0)
  5263.      {
  5264.         printf("\007SYSMON: Can't get memory by the system !\n");
  5265.         exit(errno);
  5266.      }
  5267.   }
  5268.   argblk[ARG_ENV_NUM-1]=(char *) 0;
  5269.  
  5270.  
  5271.   porthandle=_gs_devn(0,portnam);
  5272.   if(porthandle==-1)
  5273.   {
  5274.     printf("\n\007SYSMON: Can't get own device-name !\n");
  5275.     sleep(1);
  5276.     exit(errno);
  5277.   }  
  5278.   uppercase(portnam);
  5279.  
  5280.   if(argc>1)
  5281.   {
  5282.     for(i=1;i<argc;i++)
  5283.     {
  5284.       cpoi=argv[i];
  5285.       if(*cpoi !='-')
  5286.       {
  5287.         cursoroff();
  5288.         helpuser();
  5289.         cursoron();
  5290.         if(strncmp(portnam,"PKS",3)==0)
  5291.             sleep(2);
  5292.         exit(0);
  5293.       }
  5294.       while(*cpoi++ != 0)
  5295.       {
  5296.         switch(tolower(*cpoi))
  5297.         {
  5298.         case '?':
  5299.           cursoroff();
  5300.           helpuser();
  5301.           cursoron();
  5302.           if(strncmp(portnam,"PKS",3)==0)
  5303.             sleep(2);
  5304.           exit(0);  
  5305.           break;
  5306.         case 'b':
  5307.           exmode=1;
  5308.           mode_flag=1;
  5309.           abort=TRUE;        
  5310.           break;
  5311.         case 'e':
  5312.           exmode=2;
  5313.           mode_flag=1;
  5314.           abort=TRUE;        
  5315.           break;
  5316.         case 'a':
  5317.           exmode=0;
  5318.           mode_flag=1;
  5319.           abort=TRUE;        
  5320.           break;
  5321.         case 'c':
  5322.           clflg=TRUE;
  5323.           abort=TRUE;
  5324.           break;
  5325.         case 'j':
  5326.           maxh_flag=TRUE;
  5327.           abort=TRUE;  
  5328.           break;
  5329.         case 'm':
  5330.           mark=TRUE;
  5331.           abort=TRUE;
  5332.           break;
  5333.         case 'p':
  5334.           prior_flag=TRUE;
  5335.           abort=TRUE;
  5336.           break;
  5337.         case 'q':
  5338.           prillow=FALSE;
  5339.           abort=TRUE;
  5340.           break;
  5341.         case 'u':
  5342.           mode_flag=1;
  5343.           active_flag=1;
  5344.           abort=TRUE;        
  5345.           break;
  5346.         case 'd':
  5347.           default_flag=TRUE;
  5348.           abort=TRUE;        
  5349.           break;
  5350.         case 'r':
  5351.           reference=TRUE;
  5352.           abort=TRUE;
  5353.           break;
  5354.         case 'w':
  5355.           watchy_flag=TRUE;
  5356.           abort=TRUE;
  5357.           break;
  5358.         case 'v':
  5359.           if(show_version()==1)
  5360.             cls();
  5361.           if(strncmp(portnam,"PKS",3)==0)
  5362.             sleep(2);
  5363.           exit(0);  
  5364.           break;  
  5365.         case 't':
  5366.           ppoi=cpoi;
  5367.           if(*(++ppoi) != '=')
  5368.           {
  5369.             cursoroff();
  5370.             helpuser();
  5371.             cursoron();
  5372.             if(strncmp(portnam,"PKS",3)==0)
  5373.                 sleep(2);
  5374.             exit(0);
  5375.           }
  5376.           ++ppoi;
  5377.           delay = atoi(ppoi);
  5378.           if(delay >60)
  5379.              delay=60;
  5380.           if(delay< 1)
  5381.              delay=1;
  5382.           abort=TRUE;
  5383.           myolddelay=delay;
  5384.           break;
  5385.         }
  5386.       }
  5387.       if(!abort)
  5388.       {
  5389.         cursoroff();
  5390.           helpuser();
  5391.         cursoron();
  5392.         if(strncmp(portnam,"PKS",3)==0)
  5393.             sleep(2);
  5394.         exit(0);
  5395.       }
  5396.     }
  5397.   }
  5398.  
  5399.  
  5400.   /* get system information for TERMINAL  */
  5401.   termcheck();
  5402.  
  5403.   /* get system information from init module ! */
  5404.   fmodpoi=(char *) (modlink("init",0));
  5405.   if(fmodpoi!= (char *) (-1))
  5406.   {
  5407.     munlink(fmodpoi);
  5408.     cpyh=_cpymem(0, sizeof(initbuf), fmodpoi, initbuf);
  5409.     sprintf(os9vers,"V%d.%d",*(initbuf+0x57),*(initbuf+0x58));
  5410.     if((*(initbuf+0x57)<2) || (*(initbuf+0x58)<3))
  5411.     {
  5412.         cls();
  5413.         gotoxy(1,23);
  5414.         printf(
  5415.         "\033[K\007\033[7;7m SYSMON-ERROR: \033[0;0m OS9/68k %s is too old for SYSMON %s\n"
  5416.         ,os9vers,versi);
  5417.         if(strncmp(portnam,"PKS",3)==0)
  5418.             sleep(2);
  5419.         exit(172);
  5420.     }
  5421.   }
  5422.   else
  5423.   {
  5424.     cls();
  5425.     gotoxy(1,23);
  5426.     printf("\033[K\007\033[7;7m SYSMON-ERROR: \033[0;0m Can't access 'INIT' module !\n");
  5427.     if(strncmp(portnam,"PKS",3)==0)
  5428.         sleep(2);
  5429.     exit(0);
  5430.   } 
  5431.  
  5432.   if(default_flag && fmodpoi!=(char *) (-1))
  5433.   {
  5434.     Sysdev_poi=(short *) (initbuf+0x40); 
  5435.     Sysdev_offset=*Sysdev_poi;
  5436.     strcpy(ddnam,initbuf+Sysdev_offset);
  5437.   }
  5438.   else
  5439.     sprintf(ddnam,"/dd");
  5440.  
  5441.   sprintf(nodedefnam,"%s/sys/nodedef",ddnam);
  5442.   sprintf(passwordnam,"%s/sys/password",ddnam);
  5443.  
  5444.   processor=_getsys(D_MPUType,4);
  5445.  
  5446.   if(processor>68010 || (strncmp(portnam,"TERM",4))!=0)
  5447.   {
  5448.       if(strncmp(portnam,"PKS",3)==0)
  5449.       {    
  5450.            olddelay=6;
  5451.         stdout->_flag |=_UNBUF;
  5452.       }
  5453.       else    
  5454.           olddelay=4;
  5455.   }
  5456.   
  5457.   if(delay>olddelay)
  5458.     olddelay=delay;
  5459.   else
  5460.     delay=olddelay;
  5461.  
  5462.   myolddelay=delay;
  5463.   intercept(gotsignl);      /* setup Intercept routine */
  5464.   check_it();
  5465.   setuid(0);  
  5466.   
  5467.   nodedef=fopen(nodedefnam,"r");
  5468.   if(nodedef)
  5469.   {
  5470.     fscanf(nodedef,"%s",nodename);
  5471.     fclose(nodedef);
  5472.     nodenamlen=strlen(nodename);
  5473.  
  5474.     if(nodenamlen<2 || nodenamlen>10)
  5475.     {
  5476.         setuid(oldgrp*65536+oldus);
  5477.         cursoron();
  5478.           printf(
  5479.         "\007\033[7;7m SYSMON-ERROR: \033[0;0m illegal nodenamelength !   [1 < nodename < 11 ]\n\n");
  5480.         if(strncmp(portnam,"PKS",3)==0)
  5481.             sleep(2);
  5482.         exit(0);
  5483.     }
  5484.     else
  5485.         nodeflag=TRUE;
  5486.   }
  5487.   else
  5488.   {
  5489.         if(errno==216 && privileg==TRUE)
  5490.         {
  5491.             tmode(0,0);
  5492.             nodeflag=nodedefcreate();
  5493.             tmode(0,1);
  5494.         }
  5495.       else
  5496.             nodeflag=FALSE;
  5497.   }  
  5498.   pwh=get_password();    
  5499.   if(!pwh)
  5500.     name_flag=FALSE;
  5501.  
  5502.   if(argc==1)
  5503.     loadusersetup();
  5504.  
  5505.   setuid(oldgrp*65536+oldus);
  5506.  
  5507.   for(i=0;i<MAXPROCS;maxprocent[i++]=0);
  5508.  
  5509.   switch_ctrl(GET);           /* get setings of tmode    */
  5510.   switch_ctrl(OFF);           /* disable ^C  &  ^E       */
  5511.   tmode(0,0);                /* nopause noecho !        */
  5512.   display();
  5513. }
  5514. /*---------------------- END OF SYSMON - SOURCE -----------------------------*/
  5515.