home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume10 / sxt-sh-jobs / part02 / xec.c.Diff < prev   
Encoding:
Text File  |  1987-06-22  |  13.3 KB  |  693 lines
  1. *** xec.c    Mon Nov 24 17:49:32 1986
  2. --- /cs/simon/c/shdiff-sources/xec.c    Fri Feb 20 14:36:02 1987
  3. ***************
  4. *** 13,18
  5.   #include    "sym.h"
  6.   #include    "hash.h"
  7.   
  8.   static int    parent;
  9.   
  10.   /* ========    command execution    ========*/
  11.  
  12. --- 13,22 -----
  13.   #include    "sym.h"
  14.   #include    "hash.h"
  15.   
  16. + #ifdef JOB
  17. + #include "job.h"
  18. + #endif JOB
  19. + 
  20.   static int    parent;
  21.   
  22.   
  23. ***************
  24. *** 15,20
  25.   
  26.   static int    parent;
  27.   
  28.   /* ========    command execution    ========*/
  29.   
  30.   
  31.  
  32. --- 19,25 -----
  33.   
  34.   static int    parent;
  35.   
  36. + 
  37.   /* ========    command execution    ========*/
  38.   
  39.   
  40. ***************
  41. *** 87,92
  42.                   struct ionod    *io = t->treio;
  43.                   short     cmdhash;
  44.                   short    comtype;
  45.   
  46.                   exitval = 0;
  47.   
  48.  
  49. --- 92,100 -----
  50.                   struct ionod    *io = t->treio;
  51.                   short     cmdhash;
  52.                   short    comtype;
  53. + #ifdef JOB
  54. +                 char *fgcom[3];
  55. + #endif
  56.   
  57.                   exitval = 0;
  58.   
  59. ***************
  60. *** 95,100
  61.                   com = scan(argn);
  62.                   a1 = com[1];
  63.                   gchain = schain;
  64.   
  65.                   if (argn != 0)
  66.                       cmdhash = pathlook(com[0], 1, comptr(t)->comset);
  67.  
  68. --- 103,118 -----
  69.                   com = scan(argn);
  70.                   a1 = com[1];
  71.                   gchain = schain;
  72. + #ifdef JOB
  73. +                 if (com[0][0]=='%'){
  74. +                     /* this is incredibly kludgy! */
  75. +                     fgcom[0] = "fg";
  76. +                     fgcom[1] = com[0];
  77. +                     fgcom[2] = 0;
  78. +                     com = fgcom;
  79. +                     argn=2;
  80. +                 }
  81. + #endif JOB
  82.   
  83.                   if (argn != 0)
  84.                       cmdhash = pathlook(com[0], 1, comptr(t)->comset);
  85. ***************
  86. *** 165,171
  87.                               break;    
  88.                   
  89.                           case SYSEXIT:    
  90. !                             flags |= forked;    /* force exit */    
  91.                               exitsh(a1 ? stoi(a1) : retval);
  92.                   
  93.                           case SYSNULL:    
  94.  
  95. --- 183,192 -----
  96.                               break;    
  97.                   
  98.                           case SYSEXIT:    
  99. ! #ifdef JOBSXT
  100. !                                 if ((flags&ttyflg)==ttyflg && stpjobs())
  101. !                                         error("There are blocked jobs");
  102. ! #endif JOBSXT
  103.                               exitsh(a1 ? stoi(a1) : retval);
  104.                   
  105.                           case SYSNULL:    
  106. ***************
  107. *** 250,255
  108.   #ifdef RES    /* Research includes login as part of the shell */    
  109.           
  110.                           case SYSLOGIN:    
  111.                               oldsigs();    
  112.                               execa(com, -1);
  113.                               done();    
  114.  
  115. --- 271,283 -----
  116.   #ifdef RES    /* Research includes login as part of the shell */    
  117.           
  118.                           case SYSLOGIN:    
  119. + #ifdef JOBSXT
  120. +                                 if ((flags&ttyflg)==ttyflg && stpjobs())
  121. +                                         error("There are blocked jobs");
  122. +                             sxtrelease(0);
  123. +                             nattrib(&TTYnod,N_VAR|N_EXPORT);
  124. + #endif JOBSXT
  125. +                             flags |= forked;
  126.                               oldsigs();    
  127.                               execa(com, -1);
  128.                               done();    
  129. ***************
  130. *** 260,265
  131.                                   failed(com[0], restricted);    
  132.                               else    
  133.                               {    
  134.                                   flags |= forked;    /* force bad exec to terminate shell */    
  135.                                   oldsigs();    
  136.                                   execa(com, -1);
  137.  
  138. --- 288,299 -----
  139.                                   failed(com[0], restricted);    
  140.                               else    
  141.                               {    
  142. + #ifdef JOBSXT
  143. +                                     if ((flags&ttyflg)==ttyflg && stpjobs())
  144. +                                             error("There are blocked jobs");
  145. +                                 sxtrelease(0);
  146. +                                 nattrib(&TTYnod,N_EXPORT);
  147. + #endif JOBSXT
  148.                                   flags |= forked;    /* force bad exec to terminate shell */    
  149.                                   oldsigs();    
  150.                                   execa(com, -1);
  151. ***************
  152. *** 335,340
  153.                               break;    
  154.                   
  155.                           case SYSWAIT:    
  156.                               await(a1 ? stoi(a1) : -1, 1);    
  157.                               break;    
  158.                   
  159.  
  160. --- 369,377 -----
  161.                               break;    
  162.                   
  163.                           case SYSWAIT:    
  164. + #ifdef JOB
  165. +                             await(a1 ? stoi(a1) : -1, WAIT_BG);    
  166. + #else
  167.                               await(a1 ? stoi(a1) : -1, 1);    
  168.   #endif
  169.                               break;    
  170. ***************
  171. *** 336,341
  172.                   
  173.                           case SYSWAIT:    
  174.                               await(a1 ? stoi(a1) : -1, 1);    
  175.                               break;    
  176.                   
  177.                           case SYSREAD:    
  178.  
  179. --- 373,379 -----
  180.                               await(a1 ? stoi(a1) : -1, WAIT_BG);    
  181.   #else
  182.                               await(a1 ? stoi(a1) : -1, 1);    
  183. + #endif
  184.                               break;    
  185.                   
  186.                           case SYSREAD:    
  187. ***************
  188. *** 547,552
  189.                                       unset_name(*com);
  190.                               }
  191.                               break;
  192.   
  193.                           default:    
  194.                               prs_buff("unknown builtin\n");
  195.  
  196. --- 585,615 -----
  197.                                       unset_name(*com);
  198.                               }
  199.                               break;
  200. + #ifdef JOB
  201. +                         case SYSKILL:
  202. +                             zipkill(argn,com);
  203. +                             break;
  204. +                         case SYSSTOP:
  205. +                             zipstop(argn,com);
  206. +                             break;
  207. +                         case SYSJOBS:
  208. +                             listjobs(com[1]);
  209. +                             break;
  210. +                         case SYSFG:
  211. + # ifdef JOBSXT
  212. +                             if (sxtchan==-1)
  213. +                                 failed(com[0],badexec);
  214. +                             else 
  215. + # endif JOBSXT
  216. +                               fg(findjob(com[1]));
  217. +                             break;
  218. +                         case SYSBG:
  219. +                             bg(findjob(com[1]));
  220. +                             break;
  221. +                         case SYSNOTIFY:
  222. +                             notify(findjob(com[1]));
  223. +                             break;
  224. + # ifdef JOBSXT
  225.   
  226.                           case SYSSXT1:
  227.                               {
  228. ***************
  229. *** 548,553
  230.                               }
  231.                               break;
  232.   
  233.                           default:    
  234.                               prs_buff("unknown builtin\n");
  235.                           }    
  236.  
  237. --- 611,632 -----
  238.                               break;
  239.   # ifdef JOBSXT
  240.   
  241. +                         case SYSSXT1:
  242. +                             {
  243. +                                 int chsxt;
  244. +                                 extern int crisps;
  245. + 
  246. +                                 if (com[1]){
  247. +                                     chsxt = hide_sxt();
  248. +                                     execexp(com[1],&com[2]);
  249. +                                     if (chsxt)
  250. +                                         restore_sxt();    
  251. +                                 }
  252. +                             }
  253. +                             break;
  254. + # endif JOBSXT
  255. + #endif JOB
  256. + 
  257.                           default:    
  258.                               prs_buff("unknown builtin\n");
  259.                           }    
  260. ***************
  261. *** 586,591
  262.               }
  263.   
  264.           case TFORK:
  265.               exitval = 0;
  266.               if (execflg && (treeflgs & (FAMP | FPOU)) == 0)
  267.                   parent = 0;
  268.  
  269. --- 665,674 -----
  270.               }
  271.   
  272.           case TFORK:
  273. + #ifdef JOB
  274. +             forkprocess(t,treeflgs,com,pf1,pf2,type,execflg,errorflg,pos,exec_link,linked);
  275. +             break;
  276. + #else
  277.               exitval = 0;
  278.               if (execflg && (treeflgs & (FAMP | FPOU)) == 0)
  279.                   parent = 0;
  280. ***************
  281. *** 719,724
  282.                   }
  283.                   done();
  284.               }
  285.   
  286.           case TPAR:
  287.               execute(parptr(t)->partre, exec_link, errorflg);
  288.  
  289. --- 802,808 -----
  290.                   }
  291.                   done();
  292.               }
  293. + #endif JOB
  294.   
  295.           case TPAR:
  296.               execute(parptr(t)->partre, exec_link, errorflg);
  297. ***************
  298. *** 857,862
  299.   int    f;
  300.   {
  301.       struct fileblk    fb;
  302.   
  303.       push(&fb);
  304.       if (s)
  305.  
  306. --- 941,949 -----
  307.   int    f;
  308.   {
  309.       struct fileblk    fb;
  310. + #ifdef JOBSXT
  311. +     BOOL chsxt=FALSE;
  312. + #endif JOBSXT
  313.   
  314.       push(&fb);
  315.       if (s)
  316. ***************
  317. *** 864,870
  318.           estabf(s);
  319.           fb.feval = (char **)(f);
  320.       }
  321. !     else if (f >= 0)
  322.           initf(f);
  323.       execute(cmd(NL, NLFLG | MTFLG), 0, (int)(flags & errflg));
  324.       pop();
  325.  
  326. --- 951,957 -----
  327.           estabf(s);
  328.           fb.feval = (char **)(f);
  329.       }
  330. !     else if (f >= 0){
  331.           initf(f);
  332.   #ifdef JOBSXT
  333.           chsxt = hide_sxt();
  334. ***************
  335. *** 866,871
  336.       }
  337.       else if (f >= 0)
  338.           initf(f);
  339.       execute(cmd(NL, NLFLG | MTFLG), 0, (int)(flags & errflg));
  340.       pop();
  341.   }
  342.  
  343. --- 953,963 -----
  344.       }
  345.       else if (f >= 0){
  346.           initf(f);
  347. + #ifdef JOBSXT
  348. +         chsxt = hide_sxt();
  349. + #endif JOBSXT
  350. +     }
  351. +     else error("execexp: no args");
  352.       execute(cmd(NL, NLFLG | MTFLG), 0, (int)(flags & errflg));
  353.       pop();
  354.   #ifdef JOBSXT
  355. ***************
  356. *** 868,873
  357.           initf(f);
  358.       execute(cmd(NL, NLFLG | MTFLG), 0, (int)(flags & errflg));
  359.       pop();
  360.   }
  361.   
  362.   execprint(com)
  363.  
  364. --- 960,969 -----
  365.       else error("execexp: no args");
  366.       execute(cmd(NL, NLFLG | MTFLG), 0, (int)(flags & errflg));
  367.       pop();
  368. + #ifdef JOBSXT
  369. +     if (chsxt)
  370. +         restore_sxt();
  371. + #endif JOBSXT
  372.   }
  373.   
  374.   
  375. ***************
  376. *** 870,875
  377.       pop();
  378.   }
  379.   
  380.   execprint(com)
  381.       char **com;
  382.   {
  383.  
  384. --- 966,974 -----
  385.   #endif JOBSXT
  386.   }
  387.   
  388. + 
  389. + 
  390. + 
  391.   execprint(com)
  392.       char **com;
  393.   {
  394. ***************
  395. *** 885,887
  396.   
  397.       newline();
  398.   }
  399.  
  400. --- 984,1275 -----
  401.   
  402.       newline();
  403.   }
  404. + 
  405. + #ifdef JOB
  406. + /*
  407. +  * service-things for job-control.
  408. +  */
  409. + /*ARGSUSED*/
  410. + zipkill(argc,argv)
  411. + char **argv;
  412. + {
  413. +     int signo, procid, ret;
  414. +     char * a1 = argv[1];
  415. +     extern char * sys_errlist[];
  416. + 
  417. +     if (!a1) failed(argv[0],synmsg);
  418. +     if (*a1=='-'){
  419. +         a1++;
  420. +         signo=stoi(a1);
  421. +         argv++;
  422. +     } else signo=SIGTERM;
  423. +     while (*++argv){
  424. +         if (**argv=='%'){
  425. +             procid = jobs[findjob(argv[0])]->jb_pgrp;
  426. +             ret = killpg(procid,signo);
  427. +         } else {
  428. +             procid = stoi(*argv);
  429. +             ret = kill(procid,signo);
  430. +             if (ret==-1) ret=errno;
  431. +         }
  432. +         if (ret!=0){
  433. +             prn_buff(procid);
  434. +             prs_buff(" ");
  435. +             prs_buff(procid,sys_errlist[ret]);
  436. +             newline();
  437. +         }
  438. +     }
  439. +     }
  440. + 
  441. + /* ------------------------------- stop ------------------------------ */
  442. + /*ARGSUSED*/
  443. + zipstop(argc,argv)
  444. + char **argv;
  445. + {
  446. +     int id;
  447. + 
  448. +     if (argv[1]==0){
  449. +         register int i;
  450. + 
  451. +         for (i=1; i<JOB_MAX; i++)
  452. +             if (jobs[i]){
  453. + # ifdef JOBSXT
  454. +                 sxtblk(i);
  455. + # endif JOBSXT
  456. +             }
  457. +     } else {
  458. +         argv++;
  459. +         while (argv[1]){
  460. +             if (jobs[id=findjob(argv[1])]){
  461. + # ifdef JOBSXT
  462. +                 sxtblk(id);
  463. + # endif JOBSXT
  464. +             }
  465. +             argv++;
  466. +         }
  467. +     }
  468. + }
  469. + 
  470. + 
  471. + #ifdef JOBSXT
  472. + #undef     input
  473. + #include    <sys/types.h>
  474. + #include    <sys/tty.h>
  475. + #include    <sys/sxt.h>
  476. + #include    <sys/ipc.h>
  477. + #include    <sys/msg.h>
  478. + #endif JOBSXT
  479. + 
  480. + /*
  481. +  *    fork a process, exec the child and deal with job initialization, etc...
  482. +  *    (the parameter-passing is a bit crude)
  483. +  */
  484. + forkprocess(t,treeflgs,com,pf1,pf2,type,execflg,errorflg,pos,exec_link,linked)
  485. + register struct trenod * t;
  486. + register int treeflgs;
  487. + register char * *com;
  488. + int *pf1, *pf2;
  489. + int type,errorflg,pos,exec_link,linked;
  490. + {
  491. + #ifdef JOBSXT
  492. +     struct msgbuf msgbuffer;
  493. +     int msgqid = -1;
  494. + #endif JOBSXT
  495. + 
  496. +     exitval=0;
  497. +     if (execflg && (treeflgs&(FAMP|FPOU))==0)
  498. +         parent=0;
  499. +     else {
  500. +         int forkcnt = 1;
  501. + 
  502. +         if (treeflgs & (FAMP | FPOU))
  503. +         {
  504. +             link_iodocs(iotemp);
  505. +             linked = 1;
  506. +         }
  507. +         if ((treeflgs&FPIN)==0){
  508. +             bookjob();    /* set up a job slot */
  509. + #ifdef JOBSXT
  510. +             if (sxtchan!=-1)
  511. +                 msgqid = msgget(IPC_PRIVATE,0);
  512. + #endif JOBSXT
  513. +         }
  514. +         while ((parent=fork()) == -1){
  515. +             if ((forkcnt = (forkcnt * 2)) > FORKLIM)    /* 32 */
  516. +             {
  517. +                 switch (errno)
  518. +                 {
  519. +                 case ENOMEM:
  520. +                     error(noswap);
  521. +                     break;
  522. +                 default:
  523. +                 case EAGAIN:
  524. +                     error(nofork);
  525. +                     break;
  526. +                 }
  527. +             }
  528. +             if (trapnote&SIGSET){
  529. +                 postjclr(currentjob);
  530. + #ifdef JOBSXT
  531. +                 if (sxtchan!=-1)
  532. +                     msgctl(msgqid, IPC_RMID, (struct msqid_ds *)0);
  533. + #endif JOBSXT
  534. +                 sigchk();
  535. +             }
  536. +             alarm(forkcnt);
  537. +             pause();
  538. +         }
  539. +     }
  540. + 
  541. + 
  542. +     if (parent){
  543. +         /* This is the parent branch of fork;     */
  544. +         /* it may or may not wait for the child. */
  545. +         struct argnod *Dcom;
  546. + 
  547. +         if (treeflgs&FPCL) closepipe(pf1);
  548. +         while (type==TLST || type==TFIL || type==TFORK){
  549. +             if (type==TFORK)
  550. +                 t=forkptr(t)->forktre;
  551. +             else    t=lstptr(t)->lstlef;
  552. +             type=(t->tretyp)&COMMSK;
  553. +         }
  554. +         if (type==TCOM)
  555. +             Dcom = comptr(t)->comarg;
  556. +         else    Dcom = 0;
  557. +         if ((treeflgs&FPIN)==0){
  558. + #ifdef JOBSXT
  559. +             if (sxtchan!=-1){
  560. +                 msgrcv(msgqid, &msgbuffer,0,0,0);
  561. +                 msgctl(msgqid, IPC_RMID, (struct msqid_ds *)0);
  562. +                 sxtchan = sxtopen(SXT(currentjob));
  563. +                 newjob(parent,Dcom,treeflgs&FAMP,sxtchan);
  564. +                 if (sxtchan==-1) sxtchan=0;    /* fix */
  565. +             } else  newjob(parent,Dcom,treeflgs&FAMP,-1);
  566. + #else
  567. +             newjob(parent,Dcom,treeflgs&FAMP,0);
  568. + #endif JOBSXT
  569. +         }
  570. +         if (treeflgs&FPRS && (flags&(ttyflg|prompt))==(ttyflg|prompt)){
  571. +             prc('[');
  572. +             prn(currentjob);
  573. +             prs("]\t");
  574. +             prn(parent);
  575. +             newline();
  576. +         }
  577. +         if ((treeflgs&(FAMP|FPOU))==0)
  578. +             await(parent,WAIT_FG);    /* a process, in the foreground */
  579. +         else if ((treeflgs&FAMP)==0)
  580. +             post(parent);
  581. +         else {
  582. +             assnum(&pcsadr, parent);
  583. +             post(parent);
  584. +             bg(currentjob);        /* set it running in bg, and reset current job to 0 */
  585. +         }
  586. + 
  587. +         chktrap();
  588. +         return;
  589. + 
  590. + 
  591. +     } else    {    /* this is the forked branch (child) of execute */
  592. +         flags |= forked;
  593. +         fiotemp  = 0;
  594. + 
  595. +         if (linked == 1)
  596. +         {
  597. +             swap_iodoc_nm(iotemp);
  598. +             exec_link |= 06;
  599. +         }
  600. +         else if (linked == 0)
  601. +             iotemp = 0;
  602. + 
  603. + #ifdef ACCT
  604. +         suspacct();
  605. + #endif
  606. + 
  607. +         setchildjob(currentjob,0);
  608. +         postclr();
  609. +         settmp();
  610. + 
  611. +         /* Turn off INTR and QUIT if `FINT'  */
  612. +         /* Reset ramaining signals to parent */
  613. +         /* except for those `lost' by trap   */
  614. +         oldsigs();
  615. +         fixsigs();
  616. + #ifdef JOBSXT
  617. +         if ((iflags&jobflg)==0)
  618. + #endif JOBSXT
  619. +           if (treeflgs&FINT){
  620. +             signal(SIGINT,SIG_IGN);
  621. +             signal(SIGQUIT,SIG_IGN);
  622. + #ifdef NICE
  623. +             if (treeflgs&FAMP)
  624. +                 nice(NICEVAL);
  625. + #endif
  626. +           }
  627. + 
  628. + #ifdef JOBSXT
  629. +         /* reset fildes 0,1,2 through sxt channel */
  630. +         if (sxtchan!=-1){
  631. +             if (currentjob<SXTMAX)
  632. +                 setpgrp();
  633. +             sxtchan=sxtopen(SXT(currentjob));
  634. +             if ((treeflgs&(FPIN|FPOU))!=FPOU)    /*pipes once*/
  635. +                 setchildjob(currentjob, ((treeflgs&FAMP)==0)?1:2);
  636. +             if (sxtchan != -1){
  637. +                 close(0); close(1); close(2);
  638. +                 dup(sxtchan);
  639. +                 dup(0); dup(0); /* stdout and stderr */
  640. +             }
  641. +             sxtchan = -1;    /* prevent subshell jobs */
  642. + #ifdef SXT_SUSPEND
  643. +             if (treeflgs&FAMP)
  644. + #endif
  645. +                 close(sxt_fd);
  646. +             msgbuffer.mtype = 1;
  647. +             msgsnd(msgqid, msgbuffer, 0, 0);
  648. +             msgctl(msgqid, IPC_RMID, (struct msqid_ds *)0);    /* delete in kid too */
  649. +         }
  650. +         if ((iflags&jobflg) && (treeflgs&(FPIN|FPOU))==FPOU){
  651. +             alarm(1);
  652. +             pause();    /* Horrendous Kludge! */
  653. +         }
  654. + #endif JOBSXT
  655. + 
  656. +         /* pipe in or out */
  657. +         if (treeflgs&FPIN){
  658. +             rename(pf1[INPIPE],0);
  659. +             close(pf1[OTPIPE]);
  660. +         }
  661. +         if (treeflgs&FPOU){
  662. +             rename(pf2[OTPIPE],1);
  663. +             close(pf2[INPIPE]);
  664. +         }
  665. + 
  666. +         /* default std input for & */
  667. + #ifdef JOBSXT
  668. +         if ((iflags&jobflg)==0)       /* only if no job-control */
  669. + #endif JOBSXT
  670. +           if ((treeflgs&FINT) && ioset==0){
  671. +             int devvy = chkopen(devnull);
  672. +             rename(devvy,0);
  673. +           }
  674. + 
  675. +         iflags &= ~jobflg;
  676. + 
  677. +         /* io redirection */
  678. +         initio(t->treio,0);
  679. +         if (type!=TCOM){
  680. +             execute(forkptr(t)->forktre,exec_link|01,errorflg);
  681. +         } else if (com[0]!=ENDARGS){
  682. +             eflag = 0;
  683. +             setlist(comptr(t)->comset,N_EXPORT);
  684. +             rmtemp(0);
  685. +             execa(com,pos);
  686. +         }
  687. +         flags &= ~ttyflg;     /* don't reset tty pgrp */
  688. +         done();
  689. +     }
  690. + }
  691. + 
  692. + #endif JOB
  693.