home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume15 / cu-shell < prev    next >
Text File  |  1988-07-06  |  16KB  |  627 lines
  1. Subject:  v15i083:  A "shell" for CU, Kermit, etc.
  2. Newsgroups: comp.sources.unix
  3. Sender: sources
  4. Approved: rsalz@uunet.UU.NET
  5.  
  6. Submitted-by: bsmith@csuchico.EDU (Bennett Smith)
  7. Posting-number: Volume 15, Issue 83
  8. Archive-name: cu-shell
  9.  
  10. This program attempts to solve some of the problems with having kermit
  11. cu, and uucp sharing the same lines.  It also keeps a log of all connections
  12. that are made.  Access to costly resources such as phone lines may be
  13. restricted by way of a Call-sys file.  It will not allow the use of cu or
  14. kermit directly, thus a user cannot specify a phone number.
  15.  
  16. Hope this helps.  Chico State University has been using it for about one
  17. month, and it seems to solve most of their problems.  Have Fun.
  18.  
  19.                 Bennett (bsmith@csuchico.EDU)
  20.  
  21. # This is a shell archive, meaning:
  22. # 1. Remove everything above the #! /bin/sh line.
  23. # 2. Save the resulting text in a file.
  24. # 3. Execute the file with /bin/sh (not csh) to create the files:
  25. #    Makefile
  26. #    call.c
  27. #    call.1L
  28. #    Call-sys
  29. export PATH; PATH=/bin:$PATH
  30. if test -f 'Makefile'
  31. then
  32.     echo shar: will not over-write existing file "'Makefile'"
  33. else
  34. cat << \SHAR_EOF > 'Makefile'
  35. #      Copyright (c) 1988 Cascade Research
  36. #       All Rights Reserved              
  37. # 
  38. #      THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF CASCADE RESEARCH
  39. #     The copyright notice above does not evidence any actual or     
  40. #     intended publication of such source code                       
  41. # 
  42. #     @(#)Makefile    1.2 */
  43. # 
  44. #  WHO    MODIFICATION                DATE DONE
  45. #  ---  -------------------------------------   ---------
  46. #  cbs    Creation of Makefile for call.c        12-Apr-88
  47.  
  48. # Comment out if you don't have HonneyDANBER lockfiles.
  49. HDB        = 1
  50.  
  51. # Full path to file containing list of valid systems for call.
  52. CALLFILE    = /usr/lib/uucp/Call-sys
  53.  
  54. # Full path to call log file.
  55. LOGFILE        = /usr/lib/uucp/Call-log
  56.  
  57. # Sprintf string for pathname of lockfile.
  58. LOCKFILE    = /usr/spool/locks/LCK..%s
  59.  
  60. # Full path to kermit executable.
  61. KERMIT        = /usr/local/bin/kermit
  62.  
  63. # Full path to cu executable.
  64. CU        = /usr/bin/cu
  65.  
  66. # User and group id for uucp (used to chown the device back after call).
  67. UIDUUCP        = 5
  68. GIDUUCP        = 5
  69.  
  70. # Mode of device for kermit and uucp/cu (used to chmod the device during call). 
  71. MODKER        = 00600
  72. MODUUCP        = 00622
  73.  
  74. DEFS        = -DHDB=\"$(HDB)\" -DCALLFILE=\"$(CALLFILE)\" \
  75.           -DLOGFILE=\"$(LOGFILE)\" -DLOCKFILE=\"$(LOCKFILE)\" \
  76.           -DKERMIT=\"$(KERMIT)\" -DCU=\"$(CU)\" \
  77.           -DUIDUUCP=\"$(UIDUUCP)\" -DGIDUUCP=\"$(GIDUUCP)\" \
  78.           -DMODKER=\"$(MODKER)\" -DMODUUCP=\"$(MODUUCP)\"
  79.  
  80. # Directory for call executable
  81. BINDIR        = /usr/local/bin
  82.  
  83. # Directory for call manual page ([nt]roff form)
  84. MANDIR        = /usr/man/l_man/man1
  85.  
  86. ############################################################################
  87.  
  88. SRC        = call.c
  89. OBJ        = call.o
  90. MAN        = call.1L
  91. CFLAGS        = -O ${DEFS}
  92. LFLAGS        =
  93. LINTFLAGS    = ${DEFS}
  94. ROFF        = psroff -man
  95. LP        = remsh bugs rlp pluto
  96.  
  97. call:        $(OBJ)
  98.         cc $(LFLAGS) $(OBJ) -o call
  99.  
  100. man:
  101.         $(ROFF) $(MAN)
  102. print:
  103.         pr Makefile call.c | $(LP)
  104.         $(ROFF) $(MAN) | $(LP)
  105. clean:    
  106.         -rm -f $(OBJ) call
  107.  
  108. install:
  109.         -cp call $(BINDIR)
  110.         -cp Call-sys $(CALLFILE)
  111.         -cp call.1 $(MANDIR)
  112.         -chmod 4555 $(BINDIR)/call
  113.         -chown root $(BINDIR)/call
  114.         -chgrp bin $(BINDIR)/call
  115.         -chmod 600 $(CALLFILE)
  116.         -chown root $(CALLFILE)
  117.         -chgrp bin $(CALLFILE)
  118.         -chmod 444 $(MANDIR)/call.1
  119. SHAR_EOF
  120. fi # end of overwriting check
  121. if test -f 'call.c'
  122. then
  123.     echo shar: will not over-write existing file "'call.c'"
  124. else
  125. cat << \SHAR_EOF > 'call.c'
  126.  
  127. /*     Copyright (c) 1988 Cascade Research */
  128. /*      All Rights Reserved               */
  129.  
  130. /*     THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF CASCADE RESEARCH */
  131. /*    The copyright notice above does not evidence any actual or      */
  132. /*    intended publication of such source code                        */
  133.  
  134. /*    @(#)call.c    1.2 */
  135.  
  136. /* WHO    MODIFICATION                DATE DONE */
  137. /* ---  -------------------------------------   --------- */
  138. /* cbs    Initial creation of call.c program.    05-Apr-88 */
  139. /* cbs    Added code for the -d option.        07-Apr-88 */
  140. /* cbs    Added -l with no machine name to show    07-Apr-88 */
  141. /*    entire contents of log file.              */
  142. /* cbs    Added code to set the HUPCL value for    12-Apr-88 */
  143. /*    the device to be connected to.              */
  144.  
  145. /* Call allows the invocation of cu or kermit in a more   */
  146. /* restrictive environment.  It allows for the monitoring */
  147. /* of callers, and the duration of their connections to   */
  148. /* various machines.  Call gets a list of available       */
  149. /* machines from the Call-devices file which is located   */
  150. /* in the /usr/lib/uucp directory.  The log file of all   */
  151. /* actions is in /usr/adm/Call-log.                       */
  152.  
  153. /* Call must run setuid(root).  It respects the HDB type  */
  154. /* lock files as well as the v7 ones.  It will set the    */
  155. /* permissions and ownerships of the appropriate device   */
  156. /* for the duration of the call.                          */
  157.  
  158. #include <fcntl.h>
  159. #include <termio.h>
  160. #include <stdio.h>
  161. #include <ctype.h>
  162. #include <string.h>
  163. #include <time.h>
  164.  
  165. /* The following are the defaults.  If you wish to make changes, do so */
  166. /* in the Makefile, not here.                           */
  167.  
  168. #ifndef CALLFILE
  169. #define    CALLFILE    "/usr/lib/uucp/Call-sys"
  170. #endif
  171. #ifndef LOGFILE
  172. #define LOGFILE        "/usr/lib/uucp/Call-log"
  173. #endif
  174. #ifndef LOCKFILE
  175. #define LOCKFILE    "/usr/spool/locks/LCK..%s"
  176. #endif
  177. #ifndef KERMIT
  178. #define KERMIT        "/usr/local/bin/kermit"
  179. #endif
  180. #ifndef CU
  181. #define CU        "/usr/bin/cu"
  182. #endif
  183. #ifndef UIDUUCP
  184. #define UIDUUCP    5
  185. #endif
  186. #ifndef GIDUUCP
  187. #define GIDUUCP    5
  188. #endif
  189. #ifndef MODKER
  190. #define MODKER    00600
  191. #endif
  192. #ifndef MODUUCP
  193. #define MODUUCP 00622
  194. #endif
  195.  
  196. struct calldev {
  197.     char *name;        /* name of system */
  198.     char *dev;        /* device attached to */
  199.     char *baud;        /* baud rate to connect at */
  200.     char *mdmtype;        /* modem type */
  201.     char *telno;        /* telephone number */
  202.     struct calldev *next;    /* pointer to next available device */
  203. };
  204.  
  205. struct calldev *callhead, *callcur, *match, *getcall();
  206. char *pname, *getlogin(), typecall[50], whocall[50];
  207.  
  208. struct termio *devparam;
  209. int fd;
  210.  
  211. int errflg,kflg,cflg,lflg,sflg,dflg;
  212.  
  213. main(argc,argv)
  214. int argc;
  215. char *argv[];
  216. {
  217.     extern char *optarg;
  218.     extern int optind,opterr;
  219.     int c;
  220.     char *callsys, cmd[100];
  221.     FILE *cf, *fopen();
  222.  
  223.     devparam = (struct termio *)malloc(sizeof(struct termio));
  224.  
  225.     pname=(char *)malloc(sizeof(argv[0])+1);
  226.     strcpy(pname,argv[0]);
  227.     strcpy(typecall,"?????");
  228.     strcpy(whocall,"?????");
  229.     dflg=sflg=errflg=kflg=lflg=0;
  230.     cflg=1;
  231.  
  232.     while ((c=getopt(argc,argv,"dckls"))!=EOF)
  233.         switch (c) {
  234.             case 'd':    dflg++;
  235.                     break;    
  236.             case 'c':    cflg++;
  237.                     if (kflg) kflg=0;
  238.                     break;
  239.             case 'k':    kflg++;
  240.                     if (cflg) cflg=0;
  241.                     break;
  242.             case 'l':    lflg++;
  243.                     break;
  244.             case 's':    sflg++;
  245.                     break;
  246.             case '?':    errflg++;
  247.         }
  248.  
  249.     if (errflg || argc < 2) {
  250.         fprintf(stderr,"usage: %s [-d] [-c|-k|-l] system | [-s]\n",pname);
  251.         exit (2);
  252.     }
  253.  
  254.     callsys = argv[optind];
  255.         
  256.     if ((cf=fopen(CALLFILE,"r"))==(FILE *)NULL) {
  257.         fprintf(stderr,"%s: cannot open %s\n",pname,CALLFILE);
  258.         exit (2);
  259.     }
  260.     callhead = getcall(cf);    /* load the call structure from the CALLFILE */
  261.  
  262.     if (sflg) {
  263.         strcpy(typecall,"SYSTEM LIST");
  264.         for (callcur=callhead; callcur!=(struct calldev *)NULL; callcur=callcur->next)
  265.             printf("%s\n",callcur->name);  
  266.         exit(0);
  267.     }
  268.  
  269.     if (lflg && (optind==argc)) {
  270.         sprintf(cmd,"/bin/cat %s 2>/dev/null",LOGFILE);
  271.         system(cmd);
  272.         exit(0);
  273.     }
  274.  
  275.     match=(struct calldev *)NULL;
  276.     for (callcur=callhead; callcur!=(struct calldev *)NULL; callcur=callcur->next)
  277.         if (strcmp(callsys,callcur->name)==0) match=callcur;
  278.     if (match==(struct calldev *)NULL) {
  279.         if (!lflg) 
  280.             fprintf(stderr,"%s: %s is not a valid system\n",pname,callsys);
  281.         else
  282.             fprintf(stderr,"%s: must specify system for log viewing\n",pname);
  283.         exit (2);
  284.     }
  285.     strcpy(whocall,match->name);
  286.     if (!lflg) {
  287.         exit (kflg?dokermit(match):docu(match));
  288.     } else if (lflg)
  289.         exit (showlog(match));
  290.     exit(0);
  291. }
  292.  
  293. /* showlog() - display the log for the specified match to CALLFILE */
  294.  
  295. int showlog(where)
  296. struct calldev *where;
  297. {
  298.     char cmd[100];
  299.     sprintf(cmd,"/bin/grep %s %s 2>/dev/null",where->name,LOGFILE);
  300.     system(cmd);
  301.     return (0);
  302. }
  303.  
  304. /* dokermit() - invoke KERMIT for the specified match to CALLFILE */
  305.  
  306. int dokermit(where)
  307. struct calldev *where;
  308. {
  309.     char line[35],rmlck[70];
  310.  
  311.     strcpy(typecall,"KERMIT");
  312.     fprintf(stderr,"Calling with kermit\n");
  313.     if(checklock(where->dev)==0) {
  314.         sprintf(rmlck,"rm -f ");
  315.         sprintf(line,LOCKFILE,where->dev);
  316.         strcat(rmlck,line);
  317.         strcat(rmlck," 2>&1 1>/dev/null");
  318.         if (dflg)
  319.             fprintf(stderr,"%s: removing invalid lock file [%s]\n",pname,line);
  320.         system(rmlck);
  321.         sprintf(line,"/dev/%s",where->dev);
  322.         if (chown(line,getuid(),getgid())<0) {
  323.             fprintf(stderr,"%s: cannot chown %s for kermit\n",pname,line);
  324.             writelog("CHOWN FAILED");
  325.             exit(2);
  326.         }
  327.         if (chmod(line,MODKER)<0) {
  328.             fprintf(stderr,"%s: cannot chmod %s for kermit\n",pname,line);
  329.             writelog("CHMOD FAILED");
  330.             exit(2);
  331.         }
  332.         ioctl((fd=open(line,O_RDONLY)),devparam,TCGETA);
  333.         devparam->c_cflag=devparam->c_cflag||HUPCL;
  334.         ioctl(fd,devparam,TCSETA);
  335.         close(fd);
  336.         writelog("CONNECT");
  337.         if (fork() == 0) {
  338.             setuid(getuid());
  339.             if (dflg)
  340.                 execlp(KERMIT,"kermit","-d","-l",line,"-b",where->baud,(char *)0);
  341.             else
  342.                 execlp(KERMIT,"kermit","-l",line,"-b",where->baud,(char *)0);
  343.             fprintf(stderr,"%s: cannot execute kermit\n",pname);
  344.             exit(2);
  345.         }
  346.         wait((int *)0);
  347.         writelog("DISCONNECT");
  348.         if (chown(line,UIDUUCP,GIDUUCP)<0) {
  349.             fprintf(stderr,"%s: cannot reset %s\n",pname,line);
  350.             writelog("CHOWN FAILED");
  351.             exit(2);
  352.         }
  353.         if (chmod(line,MODUUCP)<0) {
  354.             fprintf(stderr,"%s: cannot reset %s\n",pname,line);
  355.             writelog("CHMOD FAILED");
  356.             exit(2);
  357.         }
  358.         return (0);
  359.     } else {
  360.         fprintf(stderr,"%s: line busy - try later\n",pname);
  361.         return (1);
  362.     }
  363. }
  364.  
  365. /* docu() - invoke CU for the specified match to CALLFILE */
  366.  
  367. int docu(where)
  368. struct calldev *where;
  369. {
  370.     char line[35];
  371.  
  372.     strcpy(typecall,"CU");
  373.     fprintf(stderr,"Calling with cu\n");
  374.     if(checklock(where->dev)==0) {
  375.         sprintf(line,LOCKFILE,where->dev);
  376.         ioctl((fd=open(line,O_RDONLY)),devparam,TCGETA);
  377.         devparam->c_cflag=devparam->c_cflag||HUPCL;
  378.         ioctl(fd,devparam,TCSETA);
  379.         close(fd);
  380.         writelog("CONNECT");
  381.         if (fork() == 0) {
  382.             if (dflg)
  383.                 execlp(CU,"cu","-d",where->name,(char *)0); /* run cu */
  384.             else
  385.                 execlp(CU,"cu",where->name,(char *)0); /* run cu */
  386.             fprintf(stderr,"%s: cannot execute cu\n",pname);
  387.             exit(2);
  388.         }
  389.         wait((int *)0); /* wait for cu to disconnect */
  390.         writelog("DISCONNECT");
  391.         return (0);
  392.     } else {
  393.         fprintf(stderr,"%s: line busy - try later\n",pname);
  394.         return (1);
  395.     }
  396. }
  397.  
  398. /* writelog() - write a line into the call logfile */
  399.  
  400. int writelog(desc)
  401. char *desc;
  402. {
  403.     FILE *fopen(), *log;
  404.     long clock;
  405.     
  406.     if ((log=fopen(LOGFILE,"a"))==(FILE *)NULL) {
  407.         fprintf(stderr,"%s: could not open log file\n",pname);
  408.         exit(2);
  409.     }
  410.     clock=time((long *)0);
  411.     if (dflg)
  412.         fprintf(stderr,"%-10s %-10s %-10s %-20s %s",whocall,getlogin(),typecall,desc,asctime(localtime(&clock)));
  413.     fprintf(log,"%-10s %-10s %-10s %-20s %s",whocall,getlogin(),typecall,desc,asctime(localtime(&clock)));
  414.     fclose(log);
  415.     return (0);
  416. }
  417.  
  418. /* checklock() - check that the device which we want is available */
  419. /*               return: 0=ok 1=device in use                     */
  420.  
  421. int checklock(dev)
  422. char *dev;
  423. {
  424.     char lckfile[100];
  425.     int lkpid;
  426.     FILE *lf;
  427.  
  428.     sprintf(lckfile,LOCKFILE,dev);
  429.     if (access(lckfile,0)==0) { /* check if lockfile exists */
  430. #ifdef HDB
  431.         if ((lf=fopen(lckfile,"r"))!=(FILE *)NULL) {
  432.             fscanf(lf,"%d",&lkpid);
  433.             if (kill(lkpid,0)==(-1))  /* check if line avail */
  434.                 return(0); /* pid is invalid, line avail */
  435.             else return (1); /* valid pid, line busy */
  436.         }
  437. #endif
  438.         return(1);    
  439.     }
  440.     return(0);
  441. }
  442.  
  443. /* getcall() - read and parse the CALLFILE and setup the linked list */
  444. /*             of allowed connections                                */
  445.  
  446. struct calldev *getcall(cf)
  447. FILE *cf;
  448. {
  449.     struct calldev *head, *cur;
  450.     int c; 
  451.     char tname[25], tdev[25], tbaud[25], tmdmtype[25], ttelno[25];
  452.  
  453.     cur=head=(struct calldev *)NULL;
  454.     while ((c=fgetc(cf))!=EOF)
  455.         if (c=='#' || c==' ' || c=='\t' || c=='\n')
  456.             while ((c=fgetc(cf))!='\n');
  457.         else {
  458.             ungetc(c,cf);
  459.             fscanf(cf,"%s %s %s %s %s\n",tname,tdev,tbaud,tmdmtype,ttelno);
  460.             if (cur==(struct calldev *)NULL) {
  461.                 head=(struct calldev *)malloc(sizeof(struct calldev));
  462.                 cur=head;
  463.             } else {
  464.                 cur->next=(struct calldev *)malloc(sizeof(struct calldev));
  465.                 cur=cur->next;
  466.             }
  467.             cur->name=(char *)malloc(strlen(tname)+1);
  468.             strcpy(cur->name,tname);
  469.             cur->dev=(char *)malloc(strlen(tdev)+1);
  470.             strcpy(cur->dev,tdev);
  471.             cur->baud=(char *)malloc(strlen(tbaud)+1);
  472.             strcpy(cur->baud,tbaud);
  473.             cur->mdmtype=(char *)malloc(strlen(tmdmtype)+1);
  474.             strcpy(cur->mdmtype,tmdmtype);
  475.             cur->telno=(char *)malloc(strlen(ttelno)+1);
  476.             strcpy(cur->telno,ttelno);
  477.         }
  478.     fclose(cf);
  479.     return (head);
  480. }
  481. SHAR_EOF
  482. fi # end of overwriting check
  483. if test -f 'call.1L'
  484. then
  485.     echo shar: will not over-write existing file "'call.1L'"
  486. else
  487. cat << \SHAR_EOF > 'call.1L'
  488. .TH CALL 1L local
  489. .SH NAME
  490. call \- make a connection to an available machine via cu or kermit
  491. .SH SYNOPSIS
  492. .B call "[ -d ]" "[ -ck ]" "system"
  493. .P
  494. .B call "[ -d ]" -l "[ system ]"
  495. .P
  496. .B call "[ -d ]" "-s"
  497. .SH DESCRIPTION
  498. .I Call
  499. provides a means to connect to another UNIX system, a terminal, or possibly
  500. a non-UNIX system.  It restricts access to the actual calling programs,
  501. .I cu
  502. and
  503. .IR kermit ,
  504. in an effort to limit access to expensive resources (ie. phone lines).
  505. .I Call
  506. maintains a log of all activity on the available lines.  It will only allow
  507. access to
  508. .I cu
  509. with a valid system name, thus preventing direct dialing.
  510. .P
  511. .I Call
  512. allows for the peaceful co-existence of
  513. .I kermit
  514. with 
  515. .I cu
  516. and
  517. .IR uucp ,
  518. because it will not execute
  519. .I kermit
  520. unless the specified line is currently available.  It respects HoneyDANBER
  521. lockfiles with the pid of the active process, and the older lockfiles which
  522. simply indicate that the line is used.
  523. .TP
  524. .B call
  525. accepts the following options and arguments.
  526. .TP
  527. -c
  528. Invokes
  529. .B call
  530. with
  531. .I cu
  532. as the calling program.  This is the default calling program, if neither
  533. .B "-c"
  534. or
  535. .B "-k"
  536. is present.
  537. .TP
  538. -k
  539. Invokes
  540. .B call
  541. with 
  542. .I kermit
  543. as the calling program.  It will supply
  544. .I kermit
  545. with the device name and baud rate.  Calling with
  546. .I kermit
  547. is not premitted over a dialed line.  Only "direct" connections are
  548. supported with this option.
  549. .TP
  550. system
  551. A valid system name obtained from the
  552. .B /usr/lib/uucp/Call-sys
  553. file.  To list the currently available system names, see the
  554. .B -s
  555. option below.
  556. .TP
  557. -d
  558. Turn on the debugging mode for the calling program.  This is useful
  559. when connecting over an unreliable line since the progression of the
  560. connection may be monitored.  
  561. .I Cu
  562. will display the debugging information on the screen whereas
  563. .I kermit
  564. will send all debugging information to the file
  565. .B debug.log
  566. in the current directory.
  567. .TP
  568. -s
  569. Display a list of available systems. 
  570. .TP
  571. -l
  572. List the log file for the specified system name.  If no system is
  573. specified, the entire log is displayed, sorted by machine and then
  574. by time.
  575. .SH FILES
  576. .P
  577. /usr/lib/uucp/Call-sys
  578. .P
  579. /usr/lib/uucp/Call-log
  580. /usr/spool/uucp/LCK..(tty-device)
  581. .SH SEE ALSO
  582. .P
  583. cu(1C), uucp(1C), kermit(1L)
  584. .SH DIAGNOSTICS
  585. .P
  586. Exit code is zero for normal exit, non-zero (various values) otherwise.
  587. .SH BUGS
  588. As yet, none have been reported.
  589. .SH AUTHORS
  590. .P
  591. Bennett Smith
  592. .br
  593. Jim Garlick
  594. SHAR_EOF
  595. fi # end of overwriting check
  596. if test -f 'Call-sys'
  597. then
  598.     echo shar: will not over-write existing file "'Call-sys'"
  599. else
  600. cat << \SHAR_EOF > 'Call-sys'
  601. # Connections contains a list of all valid connections for the call
  602. # program.
  603. #
  604. # Line syntax:
  605. #    system \t device \t baud \t modemtype \t telno
  606. #
  607. # If an argument does not apply, use a dash '-' as a place holder for it.
  608. # There must be 5 arguments per line, and comments are NOT allowed to
  609. # follow the arguments.  Comments are OK on other lines, and start with
  610. # a hatch '#' character.
  611. #
  612. # The system and device fields are always necessary, but the baud, modemtype,
  613. # and telno fields are only used by kermit.
  614. #
  615. # examples -
  616. #    bugs tty106 9600 - -
  617. #    bunky tty021 9600 - -
  618. #
  619. SHAR_EOF
  620. fi # end of overwriting check
  621. #    End of shell archive
  622. exit 0
  623. -- 
  624. Cascade Research                        | uucp:     ihnp4!csun!csuchico!bsmith
  625. Bennett Smith, Software Engineer        | voice:    (916) 343-5731
  626.  
  627.