home *** CD-ROM | disk | FTP | other *** search
/ Netware Super Library / Netware Super Library.iso / remote / jservr / jserver.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-01-15  |  19.0 KB  |  597 lines
  1. /***************************************************************************** 
  2.  * 
  3.  * Program Name:jserver - Generic Job Server Front-End 
  4.  * 
  5.  * Filename:jserver.c 
  6.  * 
  7.  * Date Created:  November 21, 1988 
  8.  * 
  9.  * Version:  1.0 
  10.  * 
  11.  * Programmers:Tom Brough, Milt Anderson, Cliff Ross, Greg Peto 
  12.  * 
  13.  * Files used:..\genjob.obj 
  14.  * 
  15.  * Date Modified: Jan. 28, 1989 
  16.  * 
  17.  * Modifications: Reformated by Gregory J. Peto 
  18.  * 
  19.  * Comments:   
  20.  * 
  21.  *   This command line utility works in conjucntion with the generic job 
  22.  *      server utilities JSUPER, and JSERVER.  It is designed to let the 
  23.  *      user submit a dos command line to the job queue for remote 
  24.  *      execution on a job server machine. 
  25.  *   See the function of badUsage for summary of possible command line arguments 
  26.  *      to this utility.  All command line arguments are expected in the 
  27.  *      form: 
  28.  *        /<command keyword>=<command argument> 
  29.  *   To locate where global variables are initialized or set, look at 
  30.  *      ComAndInit for command line settings or for the variables as 
  31.  *      output variables passed to a function call. 
  32.  *   BUGS:  A TSR utility should be designed that can catch the acknowledge 
  33.  *       signal from the server machine to the client that displays the 
  34.  *      message when sitting idol at command.com (similar to UNIX) 
  35.  *       instead of forcing user to respond. 
  36.  ****************************************************************************/ 
  37.  
  38. /* functions in this file: 
  39. */                            
  40. #include "..\genjob.h" 
  41. /* #include<nitipx.h> */ 
  42. #include<sys\types.h> 
  43. #include<sys\stat.h> 
  44. #include<signal.h> 
  45. #include<process.h> 
  46. #include<ctype.h> 
  47.  
  48. /* constants definitions */ 
  49. #defineVERB_TEST1        /* want verbose test messages */ 
  50.  
  51.  
  52. /* global variables and data types */ 
  53. COMMAND_ARGS command_args[] = 
  54.  /* token,     keyword     num sig,req. string,req. int */ 
  55. { 
  56. #  defineCOM_DELAY1 
  57.  { COM_DELAY,  "DELAY",    1,FALSE,TRUE}, 
  58. #  defineCOM_SERVERCOM_DELAY + 1 
  59.  { COM_SERVER, "SERVER",   1,TRUE,FALSE} 
  60. }; 
  61.  
  62. int  secWaitForCheckJob= 10;/* number seconds wait to check for job */ 
  63.  
  64. JobStruct    job;          /* QMS job struct to be used in calls */ 
  65. WORD         jobType = 0xffff;/* job type number, default is any */ 
  66. JOBFILE      jobFile;    /* buffer of job file */ 
  67. CLIENT_REC_AREAjobClientArea;/* buffer of job client record area */ 
  68. JOBFILE      serverEnviron;/* server workstation environ for 
  69.                            restoration after job finishes */ 
  70.       
  71. /* module specific varables and data types */ 
  72. /* macro definitions */ 
  73.  
  74. /*****************************************************************************/ 
  75.  
  76. main(argc,argv,envp) 
  77.  /* Descrip: 
  78.      This program supports the generic job server.  This utility 
  79.      allow the user ot submit DOS command lines to be executed 
  80.      remotely. 
  81.     Algorithm:// 
  82.          Parse and handle command line arguments, initialize defaults 
  83.      Initialize queue server status. 
  84.      Catch signals so server removed from queue if ends abnormally. 
  85.      while server is running 
  86.         if console input, handle it. 
  87.         if still running and time to check 
  88.           reset wait count 
  89.           if job to service 
  90.              service it 
  91.         wait minimum time and decrement wait count 
  92.  */ 
  93.  /* Input: */ 
  94. int argc; 
  95. char *argv[]; 
  96. char *envp[]; 
  97.   
  98. {    /* main // */ 
  99.  BOOLEANserverRunning= TRUE; 
  100.  int    waitCount= 0;    /* check immediate for job */ 
  101.  BOOLEANserverWasActive = TRUE;/* get unactive message first time 
  102.                            through */ 
  103.  int    shandler();        /* signal handler */ 
  104.  /*--------------------------------------------------main body */ 
  105. #if 0 
  106.  if (argc == 1) 
  107.    BadUsage(NULL);/* missing command line arguments */ 
  108. #endif 
  109.  
  110.  ComAndInit(--argc,++argv);/* skip past program name */ 
  111.  InitServer(jobServerConID,jobQueueID); 
  112.  /* catch any abnormal temination signals so can disconnect from queue */ 
  113.  signal(SIGINT,shandler); 
  114.  signal(SIGFPE,shandler); 
  115.  signal(SIGABRT,shandler); 
  116.  /* save server environment so can restore later */ 
  117.  GetJobEnviron(NULL,&serverEnviron); 
  118.  
  119.  while (serverRunning) 
  120.  { 
  121.    if (kbhit()) 
  122.      serverRunning= HandleConsoleInput(); 
  123.  
  124.    if (serverRunning AND waitCount <= 0) 
  125.    {   /* check for job to service */ 
  126.      waitCount= secWaitForCheckJob; 
  127.      if (CheckForJob()) 
  128.      {  /* found job to execute, and did it */ 
  129.         serverWasActive= TRUE; 
  130.         waitCount   = 0;/* check immediate again */ 
  131.      } else if (serverWasActive) 
  132.      { 
  133.         printf("\nJob Server: idle, no jobs to service.\n"); 
  134.         serverWasActive= FALSE; 
  135.      } 
  136.    } /* if waitCount */ 
  137.  
  138.    WaitIPX(18);/* wait 18 clock ticks, approx. 1 second */ 
  139.    --waitCount; 
  140.  } /* while serverRunning */ 
  141.  
  142.  JobServerExit(0); 
  143. }    /* of main */ 
  144.  
  145. /********************************************************************/ 
  146.  
  147. int shandler(ecode) 
  148.  /* Descrip: 
  149.      This function catches interrupts from OS, terminates gracefully. 
  150.     Algorithm:// 
  151.  */ 
  152.  /* Input: */ 
  153. intecode; 
  154.   
  155. {    /* // */ 
  156.  /*--------------------------------------------------main body */ 
  157.  JobServerExit(1); 
  158. }    /* end of shandler */ 
  159.   
  160. /********************************************************************/ 
  161.  
  162. BadUsage(message) 
  163.  /* Descrip: 
  164.      This function is called when a fatal error is detected in the 
  165.         command line.  It displays the command format and options 
  166.         and then exits the program. 
  167.     Algorithm:// 
  168.  */ 
  169.  /* Input: */ 
  170. char*message;/* optional explanatory message */ 
  171.  /* Output: */ 
  172.   
  173. {    /* BadUsage // */ 
  174.  /*--------------------------------------------------main body */ 
  175.  if (message) 
  176.    printf("Error: %s\n\n",message); 
  177.  printf("usage: jserver [<command parameters>]\n\n"); 
  178.  printf("   /Server=<target server with job queue>\n"); 
  179.  printf("   /Delay=<number seconds wait to query for job>\n"); 
  180.  
  181.  exit(1); 
  182. }    /* end of BadUsage */ 
  183.   
  184. /********************************************************************/ 
  185.  
  186. ComAndInit(argc,argv) 
  187.  /* Descrip: 
  188.          This function parses command line input and sets default values. 
  189.      Several global variables may be changed from their default values 
  190.         by command line arguments. 
  191.     Algorithm:// 
  192.          Scans command line arguments, overiding defaults as needed. 
  193.         See top of this file for notes on expected form of command 
  194.           line option and badUsage for specific form of commands. 
  195.      Saves remote execution command line in jobClientArea. 
  196.      Find server of target queue and save in global variable. 
  197.    BUGS: 
  198.      Not all command line options implemented yet. 
  199.  */ 
  200.  /* Input: */ 
  201. int argc; 
  202. char *argv[]; 
  203.  /* Output: */ 
  204.   
  205. {    /* ComAndInit // */ 
  206.  /* name of server with job queue */ 
  207.  char   queueServerName[MAX_FSERVER_NAME]; 
  208.  char   argString[MAX_ARG_VAR];/* command parameter variable buffer */ 
  209.  long   argInt;            /* numeric parameter variable */ 
  210.  JOB_TIMEargTime;        /* time parameter */ 
  211.  JOB_DATEargDate;        /* date parameter */ 
  212.  /*--------------------------------------------------main body */ 
  213.  queueServerName[0]= '\0'; 
  214.  
  215.  for (;argc; --argc, ++argv) 
  216.  { 
  217.    if (*argv[0] NOT= '/') 
  218.      badUsage("Unrecognized command line arguement"); 
  219.    switch (ScanArg((*argv) + 1,command_args, 
  220.           sizeof(command_args)/sizeof(COMMAND_ARGS), 
  221.           argString,&argInt,&argTime,&argDate)) 
  222.    { 
  223.      caseCOM_DELAY: 
  224.         printf("Seconds to wait to check for job set to %d\n", 
  225.           secWaitForCheckJob = argInt); 
  226.         break; 
  227.      caseCOM_SERVER: 
  228.         if (strlen(argString) > (MAX_FSERVER_NAME - 1)) 
  229.         { 
  230.           printf("Server name length must be less than %d, aborting\n", 
  231.              MAX_FSERVER_NAME - 1); 
  232.           exit(1); 
  233.         } 
  234.         strcpy(queueServerName,argString); 
  235.         break; 
  236.      default: 
  237.         printf("Internal error: ComAndInit"); 
  238.         exit(1); 
  239.    }   /* end of switch on ScanArg */ 
  240.     
  241.  } /* end of for argc loop */ 
  242.  
  243.  FindJobServer(queueServerName,TRUE); 
  244.  if (jobQueueID == NULL) 
  245.  { 
  246.    printf("Could not find any server with job queue.\n"); 
  247.    exit(1); 
  248.  } 
  249.  
  250. #  if VERB_TEST 
  251.    printf("Found server %s, connection ID %x\n", 
  252.      queueServerName ? "(default)" : queueServerName, 
  253.      jobServerConID); 
  254. #  endif 
  255. }    /* end of ComAndInit */ 
  256.   
  257. /********************************************************************/ 
  258.  
  259. InitServer(conID,queueID) 
  260.  /* Descrip: 
  261.      This function attempts register this program as a job server 
  262.         at the server conID for queue queueID. 
  263.     Algorithm:// 
  264.  */ 
  265.  /* Input: */ 
  266. BYTE conID;  /* connection ID to server with queue */ 
  267. long queueID;/* queue bindery ID for queue on server */ 
  268.  
  269.  /* Output: */ 
  270.   
  271. {    /* InitServer // */ 
  272.  intccode; 
  273.  /*--------------------------------------------------main body */ 
  274.  SetPreferredConnectionID(conID); 
  275.  if (ccode = AttachQueueServerToQueue(queueID)) 
  276.  { 
  277.    switch (ccode) 
  278.    { 
  279.      case NO_Q_RIGHTS: 
  280.         printf("Insufficient rights to be server for job queue.\n"); 
  281.         break; 
  282.      case NO_SUCH_MEMBER: 
  283.         printf("Not member of queue server list.\n"); 
  284.         break; 
  285.      case Q_HALTED: 
  286.         printf("Job queue is halted, unable to serve it.\n"); 
  287.         break; 
  288.      case SERVER_BINDERY_LOCKED: 
  289.      case BINDERY_FAILURE: 
  290.         printf("Server bindery locked or broken, unable to service.\n"); 
  291.         break; 
  292.      default: 
  293.         printf("Unable to attach to queue as server.\n"); 
  294.    }   /* end of switch ccode */ 
  295.    exit(1); 
  296.  }   /* end of if */ 
  297. }    /* end of InitServer */ 
  298.   
  299. /********************************************************************/ 
  300.  
  301. BOOLEAN HandleConsoleInput() 
  302.  /* Descrip: 
  303.      This function is called when user keyboard interraction 
  304.         detected.  Gets user input, and executes user request. 
  305.      Returns TRUE if user wished to continue as server, else FALSE. 
  306.     Algorithm:// 
  307.      Stubbed for now. 
  308.  */ 
  309.   
  310. {    /* HandleConsoleInput // */ 
  311.  /*--------------------------------------------------main body */ 
  312.  return(TRUE); 
  313. }    /* end of HandleConsoleInput  */ 
  314.   
  315. /********************************************************************/ 
  316.  
  317. BOOLEAN CheckForJob() 
  318.  /* Descrip: 
  319.      This function checks to see if there is a job in the queue it 
  320.         can service.  If one is found and executed then it returns 
  321.         TRUE, else FALSE. 
  322.     Algorithm:// 
  323.  */ 
  324.   
  325. {    /* CheckForJob // */ 
  326.  int ccode; 
  327.  int assocFile;/* associated file for job 
  328.  /*--------------------------------------------------main body */ 
  329.  SetPreferredConnectionID(jobServerConID); 
  330.  if ((ccode = ServiceQueueJobAndOpenFile(jobQueueID,jobType, 
  331.      &job,&assocFile)) == SUCCESSFUL) 
  332.  { 
  333.    DoJob(assocFile); 
  334.    return(TRUE); 
  335.  } else 
  336.    switch (ccode) 
  337.    { 
  338.      case Q_ERROR: 
  339.         printf("Server getting queue error on request to service job.\n"); 
  340.         break; 
  341.      case Q_HALTED: 
  342.         printf("Job queue is halted\n."); 
  343.         break; 
  344.      case NO_Q_JOB:/* OK, normal operation, just no jobs */ 
  345.         break; 
  346.      case SERVER_BINDERY_LOCKED: 
  347.      case BINDERY_FAILURE: 
  348.         printf("Job server experiencing problems with bindery.\n"); 
  349.         break; 
  350.      default: 
  351.         printf("Job server detected abnormal problem requesting job to service,\n"); 
  352.         printf("aborting job server program.\n"); 
  353.         JobServerExit(1); 
  354.    } 
  355.  
  356.  return(FALSE); 
  357. }    /* end of CheckForJob */ 
  358.   
  359. /********************************************************************/ 
  360.  
  361. DoJob(assocFile) 
  362.  /* Descrip: 
  363.      This fucntion uses global variables and assocFile to execute 
  364.         job attached to from job queue. 
  365.     Algorithm:// 
  366.    BUGS: 
  367.      It should detach itself from all file servers but one with queue 
  368.         so all 8 slots are available for the job.  Would then have 
  369.         to be restored later. 
  370.      It should attempt to strip memory of any TSR's that may have been 
  371.         started and are hanging in memory that could get control with 
  372.         a different job's security rights.  Maybe moot question if 
  373.         implement Reboot option in server. 
  374.      This routine should check the monitor mode and reset it to text 
  375.         if necessary. 
  376.  */ 
  377.  /* Input: */ 
  378. int  assocFile; 
  379.   
  380. {    /* DoJob // */ 
  381.  intcommandStatus; 
  382.  /*--------------------------------------------------main body */ 
  383.  printf("Setting up job #%d\n",job.jobNumber); 
  384.  ClearServerEnviron(); 
  385.  ChangeToClientRights(jobQueueID,job.jobNumber); 
  386.  read(assocFile,(char *) &jobFile,sizeof(jobFile)); 
  387.  if (SetJobEnviron(&jobFile)) 
  388.    /* environment setup successful, proceed */ 
  389.    commandStatus= SpawnJob(); 
  390.  else 
  391.    commandStatus= 1;/* mark as unsuccessful */ 
  392.  
  393.  /* signal done, no charge for doing job */ 
  394.  RestoreQueueServerRights(); 
  395.  
  396.  /* restore server environment */ 
  397.  ClearServerEnviron();/* strip any attachments gained by job */ 
  398.  SetJobEnviron(&serverEnviron); 
  399.  if (FinishServicingQueueJobAndFile(jobQueueID,job.jobNumber,(long) 0, 
  400.      assocFile)) 
  401.    printf("Job server received error when signaling done with job.\n"); 
  402.  if (jobFile.flags & DO_ACK_MESS) 
  403.    AcknowledgeClient(commandStatus); 
  404. }    /* end of DoJob */ 
  405.   
  406. /********************************************************************/ 
  407.  
  408. ClearServerEnviron() 
  409.  /* Descrip: 
  410.      This function clears the workstation internal tables so that 
  411.         they can be rebuilt for the job. 
  412.     Algorithm:// 
  413.  */ 
  414.  /* Input: */ 
  415.  /* Output: */ 
  416.   
  417. {    /* // */ 
  418.  int drive;    /* drive number checking */ 
  419.  WORD   conID;   /* connection ID for drive (1-8) */ 
  420.  /*--------------------------------------------------main body */ 
  421.  for (conID = 1; conID <= MAX_SERVER_ATTACHES; ++conID) 
  422.    if (conID NOT= jobServerConID AND IsConnectionIDInUse(conID)) 
  423.    { 
  424.      LogoutFromFileServer(conID); 
  425.      DetachFromFileServer(conID); 
  426.    } 
  427. }    /* end of ClearServerEnviron */ 
  428.   
  429. /********************************************************************/ 
  430.  
  431. int SpawnJob() 
  432.  /* Descrip: 
  433.      Spawn job command using command.com 
  434.      Returns termination code of spawned process. 
  435.     Algorithm:// 
  436.      Construct spawn execute variables.  envp is array of pointer 
  437.         to environment variable sets.  execbuf contains fullpath 
  438.         with command.com.  paramsbuf is array of ptrs to command.com 
  439.         arguments. 
  440.      Disable End Of Job (so command.com doesn't generate one) 
  441.      Spawn command.com command 
  442.      Reset End OF Job Status to old value. 
  443.      Return job completion code. 
  444.  */ 
  445.  /* Input: */ 
  446.  /* Output: */ 
  447.   
  448. {    /* SpawnJob // */ 
  449.  int i; 
  450.  char   *envp[MAX_ENV_ENTRIES + 2]; 
  451.  char   *comspec; 
  452.  char   *path; 
  453. #  defineMAXCOMPARAMS50 
  454.  char   *argv[MAXCOMPARAMS]; 
  455.  char   *comptr;           /* ptr into command string */ 
  456.  int ccode; 
  457. #  defineJOBCOMMAND (((CLIENT_REC_AREA *) &job.clientRecordArea[0])->jobCommand) 
  458.  /*--------------------------------------------------main body */ 
  459.  for (i = 0; i < jobFile.numEntries; ++i) 
  460.    envp[i]= jobFile.envEntries[i]; 
  461. #if 0 
  462.  /* try to figure out why getting garbage at end of envp vector in spawned job */ 
  463.  envp[i]= "DUMMY=DUMMY"; 
  464.  envp[i+1]= NULL; 
  465. #else 
  466.  envp[i]= NULL; 
  467.  envp[i+1]= NULL; 
  468. #endif 
  469.  
  470.  if ((comspec = getenv("COMSPEC")) == NULL) 
  471.  { 
  472.    printf("COMSPEC missing from server environment.\n"); 
  473.    JobServerExit(1); 
  474.  } 
  475.  
  476.  argv[0]= comspec; 
  477.  argv[1]= "/c";/* tell command.com only execute one command */ 
  478.  i      = 2;   /* start at third entry in argv */ 
  479.  /* skip leading "space" characters */ 
  480.  while (isspace(*comptr)) 
  481.    ++comptr; 
  482.  for (comptr = JOBCOMMAND; *comptr; ++i) 
  483.  { 
  484.    if (i == MAXCOMPARAMS) 
  485.    { 
  486.      printf("Too many command line parameters to setup job.\n"); 
  487.      return(1);/* return error code */ 
  488.    } 
  489.    argv[i]= comptr; 
  490.    /* skip past parameter */ 
  491.    while (isspace(*comptr) == FALSE) 
  492.      ++comptr; 
  493.    if (*comptr == '\0') 
  494.      break;                /* nothing left */ 
  495.    *comptr++ = '\0';     /* mark end of parameter */ 
  496.    /* skip to beginning of next parameter */ 
  497.    while (isspace(*comptr)) 
  498.      ++comptr; 
  499.  } 
  500.  argv[i]= NULL; 
  501.  
  502.  printf("Spawning command: %s\n",JOBCOMMAND); 
  503.  if ((ccode = spawnve(P_WAIT,comspec,argv,envp)) < 0) 
  504.  { 
  505.    printf("Job server could not execute command:\n   %s\n\n", 
  506.      JOBCOMMAND); 
  507.    perror("Spawn failed"); 
  508.    return(1); 
  509.  } 
  510.  return(ccode); 
  511. }    /* end of SpawnJob */ 
  512.   
  513. /********************************************************************/ 
  514.  
  515. AcknowledgeClient(commandStatus) 
  516.  /* Descrip: 
  517.      This function sends the client (the job submitter) 
  518.         a broadcast message that job finished. 
  519.     Algorithm:// 
  520.  */ 
  521.  /* Input: */ 
  522.  /* Output: */ 
  523.   
  524. {    /* AcknowledgeClient // */ 
  525.  char   mesBuffer[128];/* client braodcast message buffer */ 
  526.  WORD   clientStation;/* buffer for WORD value needed for 
  527.                            broadcast */ 
  528.  BYTE   resultList; 
  529.  /*--------------------------------------------------main body */ 
  530.  sprintf(mesBuffer,"Job %d %s.",job.jobNumber,(commandStatus == 0) ? 
  531.    "finished with successful completion code" : 
  532.    "failed"); 
  533.  
  534.  clientStation= job.clientStation;/* convert to WORD */ 
  535.  if (SendBroadcastMessage(mesBuffer,&clientStation,&resultList,(WORD) 1)) 
  536.    printf("Unable to broadcast messages to client.\n"); 
  537.  switch (resultList) 
  538.  { 
  539.    case0: 
  540.      break;  /* broadcast successful */ 
  541.    case0xFC: 
  542.      printf("Job client broadcast pipe full, acknowledgement failed.\n"); 
  543.      break; 
  544.    case0xFE: 
  545.      printf("Job client task does not exist, acknowledgement failed.\n"); 
  546.      break; 
  547.    case 0xFF: 
  548.      printf("Job client acknowlegement braodcast failed.\n"); 
  549.  } 
  550.  
  551. }    /* end of AcknowledgeClient */ 
  552.   
  553. /********************************************************************/ 
  554.  
  555. WaitIPX(ticks) 
  556.  /* Descrip: 
  557.      This function will loop waiting for ticks number of ticks to 
  558.         expire using IPX interface calls. 
  559.     Algorithm:// 
  560.  */ 
  561.  /* Input: */ 
  562. unsigned intticks; 
  563.   
  564. {    /* WaitIPX // */ 
  565.  static intfirsttime= 1; 
  566.  unsigned intfinishTime; 
  567.  /*--------------------------------------------------main body */ 
  568.  if (firsttime) 
  569.  { 
  570.    firsttime = 0; 
  571.    IPXInitialize();/* need to initialize internal variables */ 
  572.  } 
  573.  
  574.  finishTime = IPXGetIntervalMarker() + ticks; 
  575.  while (finishTime > IPXGetIntervalMarker()) 
  576.    ; 
  577. }    /* end of WaitIPX */ 
  578.   
  579. /********************************************************************/ 
  580.  
  581. JobServerExit(ecode) 
  582.  /* Descrip: 
  583.      Exit job server program. 
  584.     Algorithm:// 
  585.  */ 
  586.  /* Input: */ 
  587. intecode;    /* exit code to return to DOS */ 
  588.   
  589. {    /* JobServerExit // */ 
  590.  /*--------------------------------------------------main body */ 
  591.  if (DetachQueueServerFromQueue(jobQueueID)) 
  592.    printf("Job server received error code back when detaching from queue.\n"); 
  593.  exit(ecode); 
  594. }    /* end of JobServerExit */ 
  595.   
  596. /********************************************************************/ 
  597.