home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 1 / 1966 < prev    next >
Internet Message Format  |  1990-12-28  |  41KB
  1. From: ag@cbmvax.commodore.com (Keith Gabryelski)
  2. Newsgroups: alt.sources
  3. Subject: advise (spy) for streams ttys.
  4. Message-ID: <15193@cbmvax.commodore.com>
  5. Date: 16 Oct 90 23:26:25 GMT
  6.  
  7. The included source code includes
  8.  
  9.     advise.c        # a user program to interact with
  10.                 # the advise device and module.
  11.  
  12.     advisedev.c        # the advise device driver.
  13.                 # (requests to attach to a users terminal
  14.                 #  are done through this device)
  15.  
  16.     advisemod.c        # the advise module.
  17.                 # (this module is pushed onto the advisee's
  18.                 #  tty stream so advisedev may attach to
  19.                 #  it.)
  20.  
  21.     advisemod.h        # useful header file.
  22.  
  23.     COPYING Makefile    # Other files.
  24.  
  25. Pax, Keith
  26.  
  27. Ps, This will only work under System V Release 4.0 streams ttys.
  28.  
  29.     With little effort it could be made to work under other streams
  30.     tty subsystems.
  31.  
  32.     No amount of effort (save re-thinking and re-implimenting) will
  33.     make this thing work on non-streams based ttys.
  34.  
  35. #! /bin/sh
  36. # This is a shell archive, meaning:
  37. # 1. Remove everything above the #! /bin/sh line.
  38. # 2. Save the resulting text in a file.
  39. # 3. Execute the file with /bin/sh (not csh) to create the files:
  40. #    COPYING
  41. #    Makefile
  42. #    advise.c
  43. #    advise.man
  44. #    advisedev.c
  45. #    advisemod.c
  46. #    advisemod.h
  47. # This archive created: Tue Oct 16 19:15:42 1990
  48. export PATH; PATH=/bin:$PATH
  49. if test -f 'COPYING'
  50. then
  51.     echo shar: will not over-write existing file "'COPYING'"
  52. else
  53. cat << \SHAR_EOF > 'COPYING'
  54.  
  55.             Advise GENERAL PUBLIC LICENSE
  56.             (Clarified 11 Feb 1988)
  57.  
  58.  Copyright (C) 1988 Free Software Foundation, Inc.
  59.  Everyone is permitted to copy and distribute verbatim copies
  60.  of this license, but changing it is not allowed.  You can also
  61.  use this wording to make the terms for other programs.
  62.  
  63.   The license agreements of most software companies keep you at the
  64. mercy of those companies.  By contrast, our general public license is
  65. intended to give everyone the right to share Advise.  To make sure that
  66. you get the rights we want you to have, we need to make restrictions
  67. that forbid anyone to deny you these rights or to ask you to surrender
  68. the rights.  Hence this license agreement.
  69.  
  70.   Specifically, we want to make sure that you have the right to give
  71. away copies of Advise, that you receive source code or else can get it
  72. if you want it, that you can change Advise or use pieces of it in new
  73. free programs, and that you know you can do these things.
  74.  
  75.   To make sure that everyone has such rights, we have to forbid you to
  76. deprive anyone else of these rights.  For example, if you distribute
  77. copies of Advise, you must give the recipients all the rights that you
  78. have.  You must make sure that they, too, receive or can get the
  79. source code.  And you must tell them their rights.
  80.  
  81.   Also, for our own protection, we must make certain that everyone
  82. finds out that there is no warranty for Advise.  If Advise is modified by
  83. someone else and passed on, we want its recipients to know that what
  84. they have is not what we distributed, so that any problems introduced
  85. by others will not reflect on our reputation.
  86.  
  87.   Therefore we (Richard Stallman and the Free Software Foundation,
  88. Inc.) make the following terms which say what you must do to be
  89. allowed to distribute or change Advise.
  90.  
  91.  
  92.             COPYING POLICIES
  93.  
  94.   1. You may copy and distribute verbatim copies of Advise source code
  95. as you receive it, in any medium, provided that you conspicuously and
  96. appropriately publish on each copy a valid copyright notice "Copyright
  97. (C) 1988 Free Software Foundation, Inc." (or with whatever year is
  98. appropriate); keep intact the notices on all files that refer to this
  99. License Agreement and to the absence of any warranty; and give any
  100. other recipients of the Advise program a copy of this License
  101. Agreement along with the program.  You may charge a distribution fee
  102. for the physical act of transferring a copy.
  103.  
  104.   2. You may modify your copy or copies of Advise or any portion of it,
  105. and copy and distribute such modifications under the terms of
  106. Paragraph 1 above, provided that you also do the following:
  107.  
  108.     a) cause the modified files to carry prominent notices stating
  109.     that you changed the files and the date of any change; and
  110.  
  111.     b) cause the whole of any work that you distribute or publish,
  112.     that in whole or in part contains or is a derivative of Advise or
  113.     any part thereof, to be licensed at no charge to all third
  114.     parties on terms identical to those contained in this License
  115.     Agreement (except that you may choose to grant more extensive
  116.     warranty protection to some or all third parties, at your option).
  117.  
  118.     c) You may charge a distribution fee for the physical act of
  119.     transferring a copy, and you may at your option offer warranty
  120.     protection in exchange for a fee.
  121.  
  122. Mere aggregation of another unrelated program with this program (or its
  123. derivative) on a volume of a storage or distribution medium does not bring
  124. the other program under the scope of these terms.
  125.  
  126.   3. You may copy and distribute Advise (or a portion or derivative of it,
  127. under Paragraph 2) in object code or executable form under the terms of
  128. Paragraphs 1 and 2 above provided that you also do one of the following:
  129.  
  130.     a) accompany it with the complete corresponding machine-readable
  131.     source code, which must be distributed under the terms of
  132.     Paragraphs 1 and 2 above; or,
  133.  
  134.     b) accompany it with a written offer, valid for at least three
  135.     years, to give any third party free (except for a nominal
  136.     shipping charge) a complete machine-readable copy of the
  137.     corresponding source code, to be distributed under the terms of
  138.     Paragraphs 1 and 2 above; or,
  139.  
  140.     c) accompany it with the information you received as to where the
  141.     corresponding source code may be obtained.  (This alternative is
  142.     allowed only for noncommercial distribution and only if you
  143.     received the program in object code or executable form alone.)
  144.  
  145. For an executable file, complete source code means all the source code for
  146. all modules it contains; but, as a special exception, it need not include
  147. source code for modules which are standard libraries that accompany the
  148. operating system on which the executable file runs.
  149.  
  150.   4. You may not copy, sublicense, distribute or transfer Advise
  151. except as expressly provided under this License Agreement.  Any attempt
  152. otherwise to copy, sublicense, distribute or transfer Advise is void and
  153. your rights to use the program under this License agreement shall be
  154. automatically terminated.  However, parties who have received computer
  155. software programs from you with this License Agreement will not have
  156. their licenses terminated so long as such parties remain in full compliance.
  157.  
  158.   5. If you wish to incorporate parts of Advise into other free programs
  159. whose distribution conditions are different, write to the Free Software
  160. Foundation at 675 Mass Ave, Cambridge, MA 02139.  We have not yet worked
  161. out a simple rule that can be stated here, but we will often permit this.
  162. We will be guided by the two goals of preserving the free status of all
  163. derivatives of our free software and of promoting the sharing and reuse of
  164. software.
  165.  
  166. Your comments and suggestions about our licensing policies and our
  167. software are welcome!  Please contact the Free Software Foundation, Inc.,
  168. 675 Mass Ave, Cambridge, MA 02139, or call (617) 876-3296.
  169.  
  170.                NO WARRANTY
  171.  
  172.   BECAUSE ADVISE IS LICENSED FREE OF CHARGE, WE PROVIDE ABSOLUTELY NO
  173. WARRANTY, TO THE EXTENT PERMITTED BY APPLICABLE STATE LAW.  EXCEPT
  174. WHEN OTHERWISE STATED IN WRITING, FREE SOFTWARE FOUNDATION, INC,
  175. RICHARD M. STALLMAN AND/OR OTHER PARTIES PROVIDE ADVISE "AS IS" WITHOUT
  176. WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT
  177. LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  178. A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND
  179. PERFORMANCE OF ADVISE IS WITH YOU.  SHOULD ADVISE PROVE DEFECTIVE, YOU
  180. ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
  181.  
  182.  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL RICHARD M.
  183. STALLMAN, THE FREE SOFTWARE FOUNDATION, INC., AND/OR ANY OTHER PARTY
  184. WHO MAY MODIFY AND REDISTRIBUTE GNU SEND AS PERMITTED ABOVE, BE LIABLE TO
  185. YOU FOR DAMAGES, INCLUDING ANY LOST PROFITS, LOST MONIES, OR OTHER
  186. SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR
  187. INABILITY TO USE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA
  188. BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY THIRD PARTIES OR A
  189. FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS) GNU SEND, EVEN
  190. IF YOU HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES, OR FOR
  191. ANY CLAIM BY ANY OTHER PARTY.
  192. SHAR_EOF
  193. fi # end of overwriting check
  194. if test -f 'Makefile'
  195. then
  196.     echo shar: will not over-write existing file "'Makefile'"
  197. else
  198. cat << \SHAR_EOF > 'Makefile'
  199. # Copyright (C) 1990 Keith Gabryelski (ag@amix.commodore.com)
  200. #
  201. # This file is part of advise.
  202. #
  203. # advise is distributed in the hope that it will be useful,
  204. # but WITHOUT ANY WARRANTY.  No author or distributor
  205. # accepts responsibility to anyone for the consequences of using it
  206. # or for whether it serves any particular purpose or works at all,
  207. # unless he says so in writing.  Refer to the advise General Public
  208. # License for full details.
  209. # 
  210. # Everyone is granted permission to copy, modify and redistribute
  211. # advise, but only under the conditions described in the
  212. # advise General Public License.   A copy of this license is
  213. # supposed to have been given to you along with advise so you
  214. # can know your rights and responsibilities.  It should be in a
  215. # file named COPYING.  Among other things, the copyright notice
  216. # and this notice must be preserved on all copies.  */
  217. # 
  218. # Author:    Keith Gabryelski    (ag@amix.commodore.com)
  219. #
  220.  
  221. CC=gcc
  222. CFLAGS=-O
  223.  
  224. all: advise
  225.  
  226. advise.o: advisemod.h
  227. SHAR_EOF
  228. fi # end of overwriting check
  229. if test -f 'advise.c'
  230. then
  231.     echo shar: will not over-write existing file "'advise.c'"
  232. else
  233. cat << \SHAR_EOF > 'advise.c'
  234. /* Copyright (C) 1990 Keith Gabryelski (ag@amix.commodore.com)
  235.  
  236. This file is part of advise.
  237.  
  238. advise is distributed in the hope that it will be useful,
  239. but WITHOUT ANY WARRANTY.  No author or distributor
  240. accepts responsibility to anyone for the consequences of using it
  241. or for whether it serves any particular purpose or works at all,
  242. unless he says so in writing.  Refer to the advise General Public
  243. License for full details.
  244.  
  245. Everyone is granted permission to copy, modify and redistribute
  246. advise, but only under the conditions described in the
  247. advise General Public License.   A copy of this license is
  248. supposed to have been given to you along with advise so you
  249. can know your rights and responsibilities.  It should be in a
  250. file named COPYING.  Among other things, the copyright notice
  251. and this notice must be preserved on all copies.  */
  252.  
  253. /*
  254. ** Author:    Keith Gabryelski    (ag@amix.commodore.com)
  255. */
  256.  
  257. #include <sys/types.h>
  258. #include <sys/stat.h>
  259. #include <signal.h>
  260. #include <stdio.h>
  261. #include <stdlib.h>
  262. #include <unistd.h>
  263. #include <fcntl.h>
  264. #include <stropts.h>
  265. #include <poll.h>
  266. #include <sys/stream.h>
  267. #include <errno.h>
  268. #include <utmp.h>
  269. #include <pwd.h>
  270. #include <termios.h>
  271. #include <string.h>
  272. #include <ctype.h>
  273. #include "advisemod.h"
  274.  
  275. extern char *optarg;
  276.  
  277. #define max(a,b) ((a)>(b)?(a):(b))
  278.  
  279. static struct module_list
  280. {
  281.     char *name;            /* name of module */
  282.     struct module_list *next;    /* next module to be pushed */
  283. } advise_module_list =
  284. {
  285.     "advise", NULL,
  286. };
  287.  
  288. static void usage(void), advise(char *);
  289. static char *strchar(char);
  290. static struct module_list *list_modules(int, char *);
  291.  
  292. static int allow_deny_p, allow_deny;
  293. static int allow_advise_p, allow_advise;
  294. static int error_flag;
  295. static int secret, spy;
  296. static int meta_character = '~';
  297. static char *progname;
  298. static char *module = "ldterm";
  299.  
  300. int
  301. main(int argc, char **argv)
  302. {
  303.     int c, error = 0;
  304.     struct termios termios;
  305.     struct module_list *modules;
  306.  
  307.     progname = *argv;
  308.  
  309.     while((c = getopt(argc, argv, "ADM:Sadm:s?")) != EOF)
  310.     {
  311.     switch(c)
  312.     {
  313.     case 's':
  314.         spy++;
  315.         break;
  316.  
  317.     case 'S':
  318.         if (!getuid())
  319.         secret++;
  320.         break;
  321.  
  322.     case 'a':
  323.         allow_deny_p++;
  324.         allow_deny=ADVISE_ALLOW;
  325.         allow_advise_p++;
  326.         allow_advise++;
  327.         break;
  328.  
  329.     case 'd':
  330.         allow_advise_p++;
  331.         allow_advise=0;
  332.         break;
  333.  
  334.     case 'A':
  335.         allow_deny_p++;
  336.         allow_deny=ADVISE_ALLOW;
  337.         break;
  338.  
  339.     case 'D':
  340.         allow_deny_p++;
  341.         allow_deny=ADVISE_DENY;
  342.         break;
  343.  
  344.     case 'm':
  345.         meta_character = optarg[0];
  346.         break;
  347.  
  348.     case 'M':
  349.         module = optarg;
  350.         break;
  351.  
  352.     case '?':
  353.         error_flag++;
  354.         break;
  355.     }
  356.  
  357.     if (error_flag)
  358.     {
  359.         usage();
  360.     }
  361.     }
  362.  
  363.     if (allow_advise_p)
  364.     {
  365.     int status = ioctl(0, ADVISE_STATUS, &status);
  366.  
  367.     if (allow_advise && status)
  368.     {
  369.         int advise_module_pushed = 0;
  370.  
  371.         /* Push advise module on stream */
  372.         (void) ioctl(0, TCGETS, &termios);
  373.  
  374.         modules = list_modules(0, module);
  375.  
  376.         advise_module_list.next = modules;
  377.  
  378.         for (modules = &advise_module_list;
  379.          modules != NULL;
  380.          modules = modules->next)
  381.         {
  382.  
  383.         if (!strcmp(modules->name, "advise"))
  384.         {
  385.             if (advise_module_pushed)
  386.             continue;
  387.  
  388.             advise_module_pushed = 1;
  389.         }
  390.  
  391.         if (ioctl(0, I_PUSH, modules->name))
  392.         {
  393.             (void) fprintf(stderr, "%s: Couldn't I_PUSH: %s (%s).\n",
  394.                    progname, modules->name, strerror(errno));
  395.             error++;
  396.         }
  397.         }
  398.  
  399.         (void) ioctl(0, TCSETS, &termios);
  400.     }
  401.  
  402.     if (!allow_advise && !status)
  403.     {
  404.         (void) ioctl(0, TCGETS, &termios);
  405.  
  406.         modules = list_modules(0, "advise");
  407.  
  408.         while (modules != NULL)
  409.         {
  410.         if (strcmp(modules->name, "advise"))
  411.         {
  412.             if (ioctl(0, I_PUSH, modules->name))
  413.             {
  414.             (void) fprintf(stderr,
  415.                        "%s: Couldn't I_PUSH: %s (%s).\n",
  416.                        progname, modules->name,
  417.                        strerror(errno));
  418.             error++;
  419.             }
  420.         }
  421.  
  422.         modules = modules->next;
  423.         }
  424.  
  425.         (void) ioctl(0, TCSETS, &termios);
  426.     }
  427.  
  428.     if (!allow_deny_p)
  429.         return error ? 1 : 0;
  430.     }
  431.  
  432.     if (allow_deny_p)
  433.     {
  434.     if (ioctl(0, allow_deny, 0))
  435.     {
  436.         if (errno == EINVAL)
  437.         {
  438.         (void) fprintf(stderr, "%s: module \"advise\" not in stream.\n",
  439.                    progname);
  440.         }
  441.         else
  442.         {
  443.         (void) fprintf(stderr, "%s: Couldn't set advisory mode (%s).\n",
  444.                    progname, strerror(errno));
  445.         }
  446.  
  447.         return 1;
  448.     }
  449.  
  450.     return 0;
  451.     }
  452.  
  453.     /* All switches have been handled */
  454.  
  455.     argc -= optind;
  456.     argv += optind;
  457.  
  458.     if (argc > 1)
  459.     {
  460.     usage();
  461.     }
  462.  
  463.     if (argc == 0)
  464.     {
  465.     int status;
  466.  
  467.     /*
  468.     ** Status of advise.
  469.     */
  470.  
  471.     if (ioctl(0, ADVISE_STATUS, &status))
  472.     {
  473.         printf("Module \"advise\" not pushed on stream.\n");
  474.     }
  475.     else
  476.     {
  477.         printf("Advise access %s\n", status ? "allowed" : "denied");
  478.     }
  479.  
  480.     return 0;
  481.     }
  482.  
  483.     advise(*argv);
  484.  
  485.     return 0;
  486. }
  487.  
  488. void
  489. usage()
  490. {
  491.     (void) fprintf(stderr, "usage: %s [-ADad?] [-M module] | [-Ss] [-m char] [ device | username ]\n",
  492.            progname);
  493.     exit(1);
  494. }
  495.  
  496. static void
  497. advise(char *who)
  498. {
  499.     int ret, fd, metad=0;
  500.     char buf[1024], *device, *devname, *login_name, *tty_name;
  501.     struct pollfd pfds[2];
  502.     struct termios termios, oldtermios;
  503.     struct stat stbuf;
  504.     struct utmp *ut, uts;
  505.     char username[sizeof(ut->ut_name) + 1];
  506.  
  507.     username[0] = '\0';
  508.  
  509.     if (*who == '/') /* full path name */
  510.     device = who;
  511.     else
  512.     {
  513.     /* Either this is /dev/ + who OR a username */
  514.  
  515.     setutent();
  516.  
  517.     while ((ut = getutent()) != NULL)
  518.     {
  519.         if (!strncmp(who, ut->ut_name, sizeof(ut->ut_name)))
  520.         {
  521.         device = (char *)malloc(sizeof("/dev/") +
  522.                     sizeof(ut->ut_name));
  523.  
  524.         if (device == NULL)
  525.         {
  526.             (void) fprintf(stderr,
  527.                 "%s: malloc failed (Out of Memory)\n",
  528.                 progname);
  529.  
  530.             exit(1);
  531.         }
  532.  
  533.         strcpy(device, "/dev/");
  534.         strncat(device, ut->ut_name, sizeof(ut->ut_name));
  535.         device[sizeof("/dev/")+sizeof(ut->ut_name)] = '\0';
  536.  
  537.         strncpy(username, ut->ut_name, sizeof(ut->ut_name));
  538.         username[sizeof(ut->ut_name)] = '\0';
  539.         break;
  540.         }
  541.     }
  542.  
  543.     if (ut == NULL) /* Is /dev/ + who */
  544.     {
  545.         device = (char *)malloc(sizeof("/dev/") + strlen(who));
  546.  
  547.         if (device == NULL)
  548.         {
  549.         (void) fprintf(stderr, "%s: malloc failed (Out of Memory)\n",
  550.                 progname);
  551.  
  552.         exit(1);
  553.         }
  554.  
  555.         strcpy(device, "/dev/");
  556.         strcat(device, who);
  557.     }
  558.  
  559.     endutent();
  560.     }
  561.  
  562.     devname = device + sizeof("/dev/") - 1;
  563.  
  564.     if (username[0] == '\0')
  565.     {
  566.     setutent();
  567.  
  568.     strncpy(uts.ut_line, devname, sizeof(uts.ut_line));
  569.  
  570.     if ((ut = getutline(&uts)) != NULL)
  571.     {
  572.         strncpy(username, ut->ut_name, sizeof(ut->ut_name));
  573.         username[sizeof(ut->ut_name)] = '\0';
  574.     }
  575.     else
  576.     {
  577.         strcpy(username, "unknown");
  578.     }
  579.  
  580.     endutent();
  581.     }
  582.  
  583.     if (stat(device, &stbuf) < 0)
  584.     {
  585.     if (errno == ENOENT)
  586.     {
  587.         (void) fprintf(stderr, "%s: no advisee device: %s\n", progname,
  588.                device);
  589.     }
  590.     else
  591.     {
  592.         (void) fprintf(stderr,
  593.                "%s: Couldn't stat() advisee device: %s (%s)\n",
  594.                progname, device, strerror(errno));
  595.     }
  596.     exit(1);
  597.     }
  598.  
  599.     if ((fd = open("/dev/advise", O_RDWR)) < 0)
  600.     {
  601.     (void) fprintf(stderr,
  602.            "%s: Couldn't open advisory device: /dev/advise (%s)\n",
  603.            progname, strerror(errno));
  604.     exit(1);
  605.     }
  606.  
  607.     if (ioctl(fd, ADVISE_SETADVISEE, stbuf.st_rdev))
  608.     {
  609.     if (errno == EUNATCH)
  610.     {
  611.         (void) fprintf(stderr,
  612.                "%s: module \"advise\" not in place for %s\n",
  613.                progname, device);
  614.     } else if (errno == EACCES)
  615.     {
  616.         (void) fprintf(stderr, "%s: permission denied.\n", progname);
  617.     } else
  618.     {
  619.         (void) fprintf(stderr,
  620.                "%s: Couldn't set advisee: %s (%lu, %lu) (%s)\n",
  621.             progname, device, ((stbuf.st_rdev >> 16) &0xFFFF),
  622.             (stbuf.st_rdev&0xFFFF), strerror(errno));
  623.     }
  624.     exit(1);
  625.     }
  626.  
  627.     if (!secret)
  628.     {
  629.     char *str;
  630.     struct passwd *pt;
  631.  
  632.     if ((login_name = getlogin()) == NULL)
  633.     {
  634.         pt = getpwuid(getuid());
  635.  
  636.         if (pt == NULL || pt->pw_name == NULL)
  637.         {
  638.         login_name = "somebody";
  639.         }
  640.         else
  641.         {
  642.         login_name = pt->pw_name;
  643.         }
  644.     }
  645.  
  646.     if ((tty_name = ttyname(2)) != NULL)
  647.     {
  648.         if (!strncmp(tty_name, "/dev/", sizeof("/dev/")-1))
  649.         tty_name += sizeof("/dev/")-1;
  650.     }
  651.     else
  652.         tty_name = "somewhere";
  653.  
  654.     str = malloc(strlen(login_name) + strlen(tty_name) +
  655.              sizeof("[: advising :]\n\r") + strlen(username) +
  656.              strlen(devname));
  657.  
  658.     if (str)
  659.     {
  660.         struct advise_message m;
  661.         struct strbuf ctl, data;
  662.  
  663.         m.type = ADVISE_READDATA;
  664.  
  665.         ctl.len = sizeof(m);
  666.         ctl.buf = (void *)&m;
  667.  
  668.         sprintf(str, "[%s:%s %s %s:%s]\n\r", login_name,
  669.             tty_name, spy ? "spying" : "advising", username, devname);
  670.  
  671.         data.len = strlen(str);
  672.         data.buf = str;
  673.  
  674.         (void) putmsg(fd, &ctl, &data, 0);
  675.  
  676.         free(str);
  677.     }
  678.     }
  679.  
  680.  
  681.     if (!spy)
  682.     {
  683.     (void) ioctl(0, TCGETS, &termios);
  684.  
  685.     oldtermios = termios;
  686.     termios.c_cc[VMIN] = 1;
  687.     termios.c_cc[VTIME] = 0;
  688.     termios.c_lflag &= ~(ISIG|ICANON|ECHO);
  689.  
  690.     (void) ioctl(0, TCSETS, &termios);
  691.     }
  692.  
  693.     pfds[0].fd = fd;
  694.     pfds[0].events = POLLIN;
  695.  
  696.     pfds[1].fd = 0;
  697.     pfds[1].events = POLLIN;
  698.  
  699.     for (;;)
  700.     {
  701.     if (poll(pfds, 2, INFTIM) < 0)
  702.         continue;
  703.  
  704.     if ((pfds[0].revents&POLLIN) != 0) /* data from advisee ready */
  705.     {
  706.         if ((ret = read(fd, buf, sizeof(buf))) > 0)
  707.         write(1, buf, ret);
  708.     }
  709.  
  710.     if ((pfds[1].revents&POLLIN) != 0) /* data from advisor ready */
  711.     {
  712.         if ((ret = read(0, buf, sizeof(buf))) > 0)
  713.         {
  714.         if (!spy)
  715.         {
  716.             register int i;
  717.             register char *p = buf, *pp=buf;
  718.  
  719.             for (i=0; i < ret; ++i, p++)
  720.             {
  721.             if (metad)
  722.             {
  723.                 if (metad == 2)
  724.                 {
  725.                 meta_character = *p;
  726.                 printf("The meta character is now: %s\n",
  727.                        strchar(meta_character));
  728.                 pp++;
  729.                 metad = 0;
  730.                 continue;
  731.                 }
  732.  
  733.                 switch (*p)
  734.                 {
  735.                 case '=':
  736.                 metad=2;
  737.                 pp++;
  738.                 break;
  739.  
  740.                 case '?':
  741.                 {
  742.                 char *escstr = strchar(meta_character);
  743.  
  744.                 printf("Help for meta character <%s>:\n",
  745.                        escstr);
  746.                 printf("%s?\t-- This help message.\n", escstr);
  747.                 printf("%s~\t-- Send a single meta character.\n",
  748.                        escstr);
  749.                 printf("%s.\t-- Disconnect advise session.\n",
  750.                        escstr);
  751.                 printf("%s=C\t-- Change meta character to C.\n",
  752.                        escstr);
  753.                 printf("%s^Z\t-- Suspend advise session.\n",
  754.                        escstr);
  755.                 pp++;
  756.                 metad=0;
  757.                 break;
  758.                 }
  759.  
  760.                 case '.':
  761.                 {
  762.                 if (!secret)
  763.                 {
  764.                     char *str;
  765.  
  766.                     str = malloc(strlen(login_name) +
  767.                       strlen(tty_name) +
  768.                       sizeof("[/ disconnecting from :]\n") +
  769.                            strlen(username) + strlen(devname));
  770.  
  771.                     if (str)
  772.                     {
  773.                     struct advise_message m;
  774.                     struct strbuf ctl, data;
  775.  
  776.                     m.type = ADVISE_READDATA;
  777.  
  778.                     ctl.len = sizeof(m);
  779.                     ctl.buf = (void *)&m;
  780.  
  781.                     sprintf(str, "[%s/%s disconnecting from %s:%s]\n\r",
  782.                         login_name, tty_name, username,
  783.                         devname);
  784.  
  785.                     data.len = strlen(str);
  786.                     data.buf = str;
  787.  
  788.                     (void) putmsg(fd, &ctl, &data, 0);
  789.  
  790.                     free(str);
  791.                     }
  792.                 }
  793.  
  794.                 close(fd);
  795.  
  796.                 (void) ioctl(0, TCSETS, &oldtermios);
  797.  
  798.                 exit(0);
  799.                 }
  800.  
  801.                 case CTRL('Z'):
  802.                 {
  803.                 (void) ioctl(0, TCSETS, &oldtermios);
  804.                 (void) signal(SIGTSTP, SIG_DFL);
  805.                 (void) kill(0, SIGTSTP);
  806.                 (void) ioctl(0, TCSETS, &termios);
  807.                 metad=0;
  808.                 break;
  809.                 }
  810.  
  811.                 default:
  812.                 metad=0;
  813.                 break;
  814.                 }
  815.             }
  816.             else
  817.             {
  818.                 if (*p == meta_character)
  819.                 {
  820.                 int d = p - pp;
  821.  
  822.                 metad=1;
  823.  
  824.                 if (d)
  825.                     write(fd, pp, d);
  826.  
  827.                 pp += d + 1;
  828.                 i += d;
  829.                 }
  830.             }
  831.             }
  832.  
  833.             if (p - pp)
  834.             {
  835.             struct advise_message m;
  836.             struct strbuf ctl, data;
  837.  
  838.             m.type = ADVISE_DATA;
  839.  
  840.             ctl.len = sizeof(m);
  841.             ctl.buf = (void *)&m;
  842.  
  843.             data.len = p - pp;
  844.             data.buf = p;
  845.  
  846.             (void) putmsg(fd, &ctl, &data, 0);
  847.             }
  848.         }
  849.         }
  850.     }
  851.     }
  852. }
  853.  
  854. static struct module_list *
  855. list_modules(int fd, char *push_below)
  856. {
  857.     char lookbuf[max(FMNAMESZ+1,256)];
  858.     struct module_list *mp, *mpp;
  859.  
  860.     mp = NULL;
  861.  
  862.     while (ioctl(fd, I_LOOK, lookbuf) == 0)
  863.     {
  864.     if (ioctl(fd, I_POP, 0))
  865.     {
  866.         (void) fprintf(stderr, "%s: Couldn't I_POP: %s (%s).\n", progname,
  867.                lookbuf, strerror(errno));
  868.         return mp;
  869.     }
  870.  
  871.     if ((mpp = malloc(sizeof(struct module_list))) == NULL ||
  872.         (mpp->name = malloc(strlen(lookbuf) + 1)) == NULL)
  873.     {
  874.         (void) fprintf(stderr, "%s: Couldn't malloc (out of memory).\n",
  875.                progname);
  876.         return mp;
  877.     }
  878.  
  879.     mpp->next = mp;
  880.     mp = mpp;
  881.  
  882.     strcpy(mp->name, lookbuf);
  883.  
  884.     if (!strcmp(push_below, lookbuf))
  885.         break;
  886.     }
  887.  
  888.     return mp;
  889. }
  890.  
  891. static char *
  892. strchar(char character)
  893. {
  894.     static char retbuf[4];
  895.     char *p = retbuf;
  896.     int capit = 0;
  897.  
  898.     if (!isascii(character))
  899.     {
  900.     *p++ = '~';
  901.     capit = 1;
  902.     character = toascii(character);
  903.     }
  904.  
  905.     if (iscntrl(character))
  906.     {
  907.     *p++ = '^';
  908.     capit = 1;
  909.     character += '@';
  910.     }
  911.  
  912.     if (capit)
  913.     *p++ = toupper(character);
  914.     else
  915.     *p++ = character;
  916.  
  917.     *p = '\0';
  918.  
  919.     return retbuf;
  920. }
  921. SHAR_EOF
  922. fi # end of overwriting check
  923. if test -f 'advise.man'
  924. then
  925.     echo shar: will not over-write existing file "'advise.man'"
  926. else
  927. cat << \SHAR_EOF > 'advise.man'
  928. .TH advise 1
  929. .SH NAME
  930. advise \- Attach to another user.
  931. .SH SYNOPSIS
  932. .B advise
  933. [-ADad?] [-M module] | [-Ss] [-m char] [ device | username ]
  934. .SH DESCRIPTION
  935. .B Advise
  936. attaches a user (the advisor) to another user's (the advisee) terminal in
  937. such a way the the advisor can type for the advisee and view what
  938. the advisee's terminal is displaying.
  939. .PP
  940. The advisee would typically type ``advise -a'' to allow advise attaches;
  941. the advisor would then type ``advise username'' which would connect the
  942. advisors terminal the the advisee's.
  943. .PP
  944. All characters the advisor types are sent to the advisee's terminal
  945. as if the advisee typed them save the meta character.
  946. .PP
  947. The default meta character is tilde (~).  The advisor uses the meta
  948. character to disconnect or suspend the advise session.  The meta
  949. commands that are available to the advisor are:
  950. .PP
  951. .RS
  952. .TP
  953. ~?
  954. Meta character help message.
  955. .TP
  956. ~~
  957. Send the meta character to the advisee's terminal.
  958. .TP
  959. ~.
  960. Disconnect advise session.
  961. .TP
  962. ~=C
  963. Change the meta character to C.
  964. .TP
  965. ~^Z
  966. Suspend this advise session.
  967. .RE
  968. .PP
  969. In Advise mode the advisor uses ``~.'' to disconnect the advise session
  970. (Note: the advisor should use ``~~'' to send one tilde to the advisee's
  971. terminal).
  972. .PP
  973. In ``spy mode'' the advisor should use an interrupt is use to disconnect
  974. the advise session.
  975. .PP
  976. ``advise -d'' can be used by the advisee to disconnect the advise
  977. session.
  978. .SH OPTIONS
  979. .TP
  980. -A
  981. Allow advise attaches to this terminal.
  982. .TP
  983. -D
  984. Disallow advise attaches to this terminal.
  985. .TP
  986. -M module
  987. Name of module to place advise module under.
  988. .TP
  989. -S
  990. When attaching to another user, don't send the attach message.
  991. (available to the super user, only).
  992. .TP
  993. -a
  994. Push advise module on standard input stream and allow advise
  995. attaches.
  996. .TP
  997. -d
  998. Push advise module on standard input stream and disallow advise
  999. attaches.
  1000. .TP
  1001. -m char
  1002. Change the meta character to ``char''.  The default meta character
  1003. is tilde (~).
  1004. .TP
  1005. -s
  1006. Spy mode only (ie, input from the advisor is not passed to the
  1007. advisee).
  1008. .TP
  1009. device
  1010. The name of the tty device to advise.
  1011. .TP
  1012. username
  1013. The name of the user to advise.
  1014. .SH AUTHOR
  1015. .RS
  1016. .PP
  1017. Keith M. Gabryelski (ag@amix.commodore.com)
  1018. .RE
  1019. SHAR_EOF
  1020. fi # end of overwriting check
  1021. if test -f 'advisedev.c'
  1022. then
  1023.     echo shar: will not over-write existing file "'advisedev.c'"
  1024. else
  1025. cat << \SHAR_EOF > 'advisedev.c'
  1026. /* Copyright (C) 1990 Keith Gabryelski (ag@amix.commodore.com)
  1027.  
  1028. This file is part of advise.
  1029.  
  1030. advise is distributed in the hope that it will be useful,
  1031. but WITHOUT ANY WARRANTY.  No author or distributor
  1032. accepts responsibility to anyone for the consequences of using it
  1033. or for whether it serves any particular purpose or works at all,
  1034. unless he says so in writing.  Refer to the advise General Public
  1035. License for full details.
  1036.  
  1037. Everyone is granted permission to copy, modify and redistribute
  1038. advise, but only under the conditions described in the
  1039. advise General Public License.   A copy of this license is
  1040. supposed to have been given to you along with advise so you
  1041. can know your rights and responsibilities.  It should be in a
  1042. file named COPYING.  Among other things, the copyright notice
  1043. and this notice must be preserved on all copies.  */
  1044.  
  1045. /*
  1046. ** Author:    Keith Gabryelski    (ag@amix.commodore.com)
  1047. */
  1048.  
  1049. #include <sys/types.h>
  1050. #include <sys/param.h>
  1051. #include <sys/sysmacros.h>
  1052. #include <sys/signal.h>
  1053. #include <sys/file.h>
  1054. #include <sys/user.h>
  1055. #include <sys/proc.h>
  1056. #include <sys/termios.h>
  1057. #include <sys/ttold.h>
  1058. #include <sys/cmn_err.h>
  1059. #include <sys/stream.h>
  1060. #include <sys/stropts.h>
  1061. #include <sys/errno.h>
  1062. #include <sys/debug.h>
  1063. #include "advisemod.h"
  1064. #include <sys/inline.h>
  1065.  
  1066. int adviseopen(), adviseclose(), adviserput(), advisewput();
  1067. void advisesrvioc();
  1068.  
  1069. static struct module_info advisemiinfo =
  1070. {
  1071.     0, "advise", 0, INFPSZ, 2048, 128,
  1072. };
  1073.  
  1074. static struct qinit adviserinit =
  1075. {
  1076.     adviserput, NULL, adviseopen, adviseclose, NULL, &advisemiinfo,
  1077. };
  1078.  
  1079. static struct module_info advisemoinfo =
  1080. {
  1081.     42, "advise", 0, INFPSZ, 300, 200,
  1082. };
  1083.  
  1084. static struct qinit advisewinit =
  1085. {
  1086.     advisewput, NULL, adviseopen, adviseclose, NULL, &advisemoinfo,
  1087. };
  1088.  
  1089. struct streamtab adviseinfo =
  1090. {
  1091.     &adviserinit, &advisewinit, NULL, NULL,
  1092. };
  1093.  
  1094. extern struct advise_state advise_table;
  1095.  
  1096. /*ARGSUSED*/
  1097. static int
  1098. adviseopen(q, devp, flag, sflag, credp)
  1099. register queue_t *q;
  1100. dev_t *devp;
  1101. int flag, sflag;
  1102. cred_t *credp;
  1103. {
  1104.     register mblk_t *bp;
  1105.     struct advise_queue_list *ql;
  1106.     struct advise_state  *sp;
  1107.     int i;
  1108.  
  1109.     if (sflag == MODOPEN)
  1110.     return EINVAL;
  1111.  
  1112.     for (i=1; i < L_MAXMIN; ++i)
  1113.     {
  1114.     sp = &advise_table;
  1115.  
  1116.     while (sp->next != NULL)
  1117.     {
  1118.         ql = sp->next->q_list;
  1119.  
  1120.         while (ql != NULL)
  1121.         {
  1122.         if (ql->minord == i)
  1123.             break;
  1124.  
  1125.         ql = ql->next;
  1126.         }
  1127.  
  1128.         if (ql != NULL)
  1129.         break;
  1130.  
  1131.         sp = sp->next;
  1132.     }
  1133.  
  1134.     if (sp->next == NULL)
  1135.         break;
  1136.     }
  1137.  
  1138.     if (i == L_MAXMIN)
  1139.     {
  1140.     return ENOMEM;        /* no more resources */
  1141.     }
  1142.  
  1143.     *devp = makedevice(getmajor(*devp), i);
  1144.  
  1145.     if ((bp = allocb((int)sizeof(struct advise_queue_list), BPRI_MED)) == NULL)
  1146.     {
  1147.     return ENOMEM;
  1148.     }
  1149.  
  1150.     bp->b_wptr += sizeof(struct advise_queue_list);
  1151.     ql = (struct advise_queue_list *)bp->b_rptr;
  1152.     ql->savbp = bp;
  1153.     ql->next = NULL;
  1154.     ql->q = q;
  1155.     ql->state = NULL;
  1156.     ql->minord = i;
  1157.  
  1158.     q->q_ptr = (caddr_t)ql;
  1159.     WR(q)->q_ptr = (caddr_t)ql;
  1160.  
  1161.     return 0;
  1162. }
  1163.  
  1164. static
  1165. adviseclose(q)
  1166. register queue_t *q;
  1167. {
  1168.     struct advise_state *llist = &advise_table;
  1169.     struct advise_queue_list *qp = (struct advise_queue_list *)q->q_ptr;
  1170.     struct advise_queue_list *ql, *qlp;
  1171.  
  1172.     /* Remove us from the advisor's list */
  1173.  
  1174.     if (qp->state != NULL)
  1175.     {
  1176.     while (llist != NULL && llist->next != qp->state)
  1177.         llist = llist->next;
  1178.  
  1179.     if (llist != NULL)
  1180.     {
  1181.         ql = llist->next->q_list;
  1182.  
  1183.         if (ql->q == q)
  1184.         {
  1185.         llist->next->q_list = ql->next;
  1186.         }
  1187.         else
  1188.         {
  1189.         while (ql->next != NULL && ql->next->q != q)
  1190.             ql = ql->next;
  1191.  
  1192.         if (ql->next != NULL)
  1193.         {
  1194.             ql->next = ql->next->next;
  1195.         }
  1196.         }
  1197.     }
  1198.     }
  1199.  
  1200.     qp->state = NULL;
  1201.     freeb(qp->savbp);
  1202.  
  1203.     q->q_ptr = NULL;
  1204. }
  1205.  
  1206. static int
  1207. adviserput(q, bp)
  1208. struct queue *q;
  1209. mblk_t *bp;
  1210. {
  1211.     putnext(q, bp);
  1212. }
  1213.  
  1214. static int
  1215. advisewput(q, bp)
  1216. struct queue *q;
  1217. mblk_t *bp;
  1218. {
  1219.     struct advise_queue_list *qp = (struct advise_queue_list *)q->q_ptr;
  1220.     struct advise_state *sp = qp->state;
  1221.  
  1222.     switch (bp->b_datap->db_type)
  1223.     {
  1224.     case M_PROTO:
  1225.     {
  1226.     struct advise_message *ms = (struct advise_message *)bp->b_rptr;
  1227.     mblk_t *bp2 = unlinkb(bp);
  1228.  
  1229.     if (bp2)
  1230.     {
  1231.         if (sp != NULL && sp->q != NULL)
  1232.         {
  1233.         if (ms->type == ADVISE_READDATA)
  1234.         {
  1235.             putnext(WR(sp->q), bp2);
  1236.         }
  1237.         else
  1238.         {
  1239.             putnext(sp->q, bp2);
  1240.         }
  1241.         }
  1242.         else
  1243.         freemsg(bp2);
  1244.     }
  1245.  
  1246.     freemsg(bp);
  1247.  
  1248.     break;
  1249.     }
  1250.  
  1251.     case M_DATA:
  1252.     /*
  1253.     ** Write data to advisee.
  1254.     */
  1255.     if (sp != NULL && sp->q != NULL)
  1256.         putnext(sp->q, bp);
  1257.     else
  1258.         freemsg(bp);
  1259.     break;
  1260.  
  1261.     case M_IOCTL:
  1262.     case M_IOCDATA:
  1263.     advisesrvioc(q, bp);
  1264.     break;
  1265.  
  1266.     default:
  1267.     freemsg(bp);
  1268.     break;
  1269.     }
  1270. }
  1271.  
  1272. static void
  1273. advisesrvioc(q, mp)
  1274. queue_t *q;
  1275. mblk_t *mp;
  1276. {
  1277.     mblk_t *mp1;
  1278.     struct iocblk *iocbp = (struct iocblk *)mp->b_rptr;
  1279.     struct advise_queue_list *qp=(struct advise_queue_list *)q->q_ptr; 
  1280.     int s;
  1281.  
  1282.     if (mp->b_datap->db_type == M_IOCDATA)
  1283.     {
  1284.     /* For copyin/copyout failures, just free message. */
  1285.     if (((struct copyresp *)mp->b_rptr)->cp_rval)
  1286.     {
  1287.         freemsg(mp);
  1288.         return;
  1289.     }
  1290.  
  1291.     if (!((struct copyresp *)mp->b_rptr)->cp_private)
  1292.     {
  1293.         mp->b_datap->db_type = M_IOCACK;
  1294.         freemsg(unlinkb(mp));
  1295.         iocbp->ioc_count = 0;
  1296.         iocbp->ioc_rval = 0;
  1297.         iocbp->ioc_error = 0;
  1298.         putnext(RD(q), mp);
  1299.         return;
  1300.     }
  1301.     }
  1302.  
  1303.     switch (iocbp->ioc_cmd)
  1304.     {
  1305.     case ADVISE_SETADVISEE:
  1306.     {
  1307.         register dev_t p;
  1308.         struct advise_queue_list *qlp;
  1309.         struct advise_state *llist;
  1310.  
  1311.         if (qp->state != NULL) /* already advising someone */
  1312.         {
  1313.         iocbp->ioc_error = EBUSY;
  1314.         mp->b_datap->db_type = M_IOCNAK;
  1315.         iocbp->ioc_count = 0;
  1316.         putnext(RD(q), mp);
  1317.         break;
  1318.         }
  1319.  
  1320.         if (!mp->b_cont)
  1321.         {
  1322.         iocbp->ioc_error = EINVAL;
  1323.         mp->b_datap->db_type = M_IOCNAK;
  1324.         iocbp->ioc_count = 0;
  1325.         putnext(RD(q), mp);
  1326.         break;
  1327.         }
  1328.  
  1329.         p = *(dev_t *)mp->b_cont->b_rptr;
  1330.         
  1331.         s = spladvise();
  1332.  
  1333.         llist = advise_table.next;
  1334.  
  1335.         while (llist != NULL && llist->dev != p)
  1336.         {
  1337.         llist = llist->next;
  1338.         }
  1339.  
  1340.         if (llist == NULL)
  1341.         {
  1342.         splx(s);
  1343.         iocbp->ioc_error = EUNATCH;
  1344.         mp->b_datap->db_type = M_IOCNAK;
  1345.         iocbp->ioc_count = 0;
  1346.         putnext(RD(q), mp);
  1347.         break;
  1348.         }
  1349.  
  1350.         if ((llist->status & ALLOW_ADVICE) == 0 && (!suser(u.u_cred)))
  1351.         {
  1352.         splx(s);
  1353.         iocbp->ioc_error = EACCES;
  1354.         mp->b_datap->db_type = M_IOCNAK;
  1355.         iocbp->ioc_count = 0;
  1356.         putnext(RD(q), mp);
  1357.         break;
  1358.         }
  1359.  
  1360.         /*
  1361.         ** Add ourself to the list of advisors for this advisee.
  1362.         */
  1363.  
  1364.         if (llist->q_list == NULL)
  1365.         {
  1366.         qlp = llist->q_list = qp;
  1367.         }
  1368.         else
  1369.         {
  1370.         qlp = llist->q_list;
  1371.  
  1372.         while (qlp->next != NULL)
  1373.             qlp = qlp->next;
  1374.  
  1375.         qlp->next = qp;
  1376.         qlp = qp;
  1377.         }
  1378.  
  1379.         qlp->state = llist;
  1380.  
  1381.         splx(s);
  1382.  
  1383.         mp->b_datap->db_type = M_IOCACK;
  1384.         mp1 = unlinkb(mp);
  1385.         if (mp1)
  1386.         freeb(mp1);
  1387.         iocbp->ioc_count = 0;
  1388.         putnext(RD(q), mp);
  1389.         break;
  1390.     }
  1391.  
  1392.     default:
  1393.     /* Unrecognized ioctl command */
  1394.     if (canput(RD(q)->q_next))
  1395.     {
  1396.         mp->b_datap->db_type = M_IOCNAK;
  1397.         putnext(RD(q), mp);
  1398.     }
  1399.     else
  1400.         putbq(q, mp);
  1401.     break;
  1402.     }
  1403. }
  1404. SHAR_EOF
  1405. fi # end of overwriting check
  1406. if test -f 'advisemod.c'
  1407. then
  1408.     echo shar: will not over-write existing file "'advisemod.c'"
  1409. else
  1410. cat << \SHAR_EOF > 'advisemod.c'
  1411. /* Copyright (C) 1990 Keith Gabryelski (ag@amix.commodore.com)
  1412.  
  1413. This file is part of advise.
  1414.  
  1415. advise is distributed in the hope that it will be useful,
  1416. but WITHOUT ANY WARRANTY.  No author or distributor
  1417. accepts responsibility to anyone for the consequences of using it
  1418. or for whether it serves any particular purpose or works at all,
  1419. unless he says so in writing.  Refer to the advise General Public
  1420. License for full details.
  1421.  
  1422. Everyone is granted permission to copy, modify and redistribute
  1423. advise, but only under the conditions described in the
  1424. advise General Public License.   A copy of this license is
  1425. supposed to have been given to you along with advise so you
  1426. can know your rights and responsibilities.  It should be in a
  1427. file named COPYING.  Among other things, the copyright notice
  1428. and this notice must be preserved on all copies.  */
  1429.  
  1430. /*
  1431. ** Author:    Keith Gabryelski    (ag@amix.commodore.com)
  1432. */
  1433.  
  1434. #include <sys/types.h>
  1435. #include <sys/param.h>
  1436. #include <sys/signal.h>
  1437. #include <sys/file.h>
  1438. #include <sys/user.h>
  1439. #include <sys/proc.h>
  1440. #include <sys/termios.h>
  1441. #include <sys/ttold.h>
  1442. #include <sys/cmn_err.h>
  1443. #include <sys/stream.h>
  1444. #include <sys/stropts.h>
  1445. #include <sys/errno.h>
  1446. #include <sys/debug.h>
  1447. #include "advisemod.h"
  1448. #include <sys/inline.h>
  1449.  
  1450. int advisemopen(), advisemclose(), advisemrput(), advisemwput();
  1451.  
  1452. static struct module_info advisemiinfo =
  1453. {
  1454.     0, "advisemod", 0, INFPSZ, 2048, 128,
  1455. };
  1456.  
  1457. static struct qinit adviserinit =
  1458. {
  1459.     advisemrput, NULL, advisemopen, advisemclose, NULL, &advisemiinfo,
  1460. };
  1461.  
  1462. static struct module_info advisemoinfo =
  1463. {
  1464.     42, "advisemod", 0, INFPSZ, 300, 200,
  1465. };
  1466.  
  1467. static struct qinit advisewinit =
  1468. {
  1469.     advisemwput, NULL, advisemopen, advisemclose, NULL, &advisemoinfo,
  1470. };
  1471.  
  1472. struct streamtab advisemodinfo =
  1473. {
  1474.     &adviserinit, &advisewinit, NULL, NULL,
  1475. };
  1476.  
  1477. struct advise_state advise_table;
  1478.  
  1479. /*ARGSUSED*/
  1480. static int
  1481. advisemopen(q, devp, flag, sflag, credp)
  1482. register queue_t *q;
  1483. dev_t *devp;
  1484. int flag, sflag;
  1485. cred_t *credp;
  1486. {
  1487.     register struct advise_state *sp;
  1488.     register mblk_t *bp;
  1489.     struct advise_state *llist = &advise_table;
  1490.  
  1491.     if (sflag != MODOPEN)
  1492.     return EINVAL;
  1493.  
  1494.     if ((bp = allocb((int)sizeof(struct advise_state), BPRI_MED)) == NULL)
  1495.     {
  1496.     return ENOMEM;
  1497.     }
  1498.  
  1499.     bp->b_wptr += sizeof(struct advise_state);
  1500.     sp = (struct advise_state *)bp->b_rptr;
  1501.     sp->savbp = bp;
  1502.  
  1503.     sp->dev = *devp;
  1504.     sp->status = 0;        /* Deny access by default */
  1505.     sp->next = NULL;
  1506.     sp->q_list = NULL;
  1507.     sp->q = q;
  1508.  
  1509.     while (llist->next != NULL)
  1510.     {
  1511.     if (llist->next->dev == *devp)
  1512.     {
  1513.         /*
  1514.         ** We are already pushed on this stream.
  1515.         */
  1516.         freeb(bp);
  1517.  
  1518.         sp = llist->next;
  1519.  
  1520.         break;
  1521.     }
  1522.  
  1523.     llist = llist->next;
  1524.     }
  1525.  
  1526.     llist->next = sp;
  1527.  
  1528.     q->q_ptr = (caddr_t)sp;
  1529.     WR(q)->q_ptr = (caddr_t)sp;
  1530.  
  1531.     return 0;
  1532. }
  1533.  
  1534. static
  1535. advisemclose(q)
  1536. register queue_t *q;
  1537. {
  1538.     register struct advise_state *sp = (struct advise_state *)q->q_ptr;
  1539.     struct advise_state *llist = &advise_table;
  1540.     struct advise_queue_list *qp = sp->q_list;
  1541.  
  1542.     sp->status = 0;
  1543.  
  1544.     /* unlink us from the state table */
  1545.  
  1546.     while (llist->next != sp)
  1547.     llist = llist->next;
  1548.  
  1549.     llist->next = llist->next->next;
  1550.  
  1551.     while (sp->next != NULL)
  1552.     {
  1553.     /* tell each advisor that we're shutting down */
  1554.  
  1555.     flushq(sp->q, FLUSHDATA);
  1556.     putctl(sp->q->q_next, M_HANGUP);
  1557.     
  1558.     sp = sp->next;
  1559.     }
  1560.  
  1561.     freeb(sp->savbp);
  1562.  
  1563.     q->q_ptr = NULL;
  1564. }
  1565.  
  1566. static
  1567. advisemrput(q, mp)
  1568. register queue_t *q;
  1569. register mblk_t *mp;
  1570. {
  1571.     putnext(q, mp);
  1572. }
  1573.  
  1574. static
  1575. advisemwput(q, mp)
  1576. register queue_t *q;
  1577. register mblk_t *mp;
  1578. {
  1579.     struct advise_state *sp = (struct advise_state *)q->q_ptr;
  1580.     register struct advise_queue_list *qp;
  1581.     int s;
  1582.  
  1583.     switch (mp->b_datap->db_type)
  1584.     {
  1585.     case M_DATA:
  1586.     /*
  1587.     ** Write data to advisors.
  1588.     */
  1589.     s = spladvise();
  1590.     for (qp = sp->q_list; qp != NULL; qp = qp->next)
  1591.     {
  1592.         mblk_t *mp1 = copymsg(mp);
  1593.  
  1594.         if (mp1 != NULL)
  1595.         putnext(qp->q, mp1);
  1596.     }
  1597.  
  1598.     splx(s);
  1599.     break;
  1600.  
  1601.     case M_IOCTL:
  1602.     case M_IOCDATA:
  1603.     if (advisemsrvioc(q, mp)) /* handled? */
  1604.         return;
  1605.     break;
  1606.     }
  1607.  
  1608.     putnext(q, mp);
  1609. }
  1610.  
  1611. static int
  1612. advisemsrvioc(q, mp)
  1613. queue_t *q;
  1614. mblk_t *mp;
  1615. {
  1616.     mblk_t *mp1;
  1617.     struct iocblk *iocbp = (struct iocblk *)mp->b_rptr;
  1618.     struct advise_state *sp = (struct advise_state *)q->q_ptr;
  1619.  
  1620.     if (mp->b_datap->db_type == M_IOCDATA)
  1621.     {
  1622.     struct copyresp *csp = (struct copyresp *)mp->b_rptr;
  1623.  
  1624.     switch(csp->cp_cmd)
  1625.     {
  1626.     case ADVISE_STATUS:
  1627.     case ADVISE_ALLOW:
  1628.     case ADVISE_DENY:
  1629.         /* For copyin/copyout failures, just free message. */
  1630.  
  1631.         if (csp->cp_rval)
  1632.         freemsg(mp);
  1633.         else if (!csp->cp_private)
  1634.         {
  1635.         mp->b_datap->db_type = M_IOCACK;
  1636.         freemsg(unlinkb(mp));
  1637.         iocbp->ioc_count = 0;
  1638.         iocbp->ioc_rval = 0;
  1639.         iocbp->ioc_error = 0;
  1640.         putnext(RD(q), mp);
  1641.         }
  1642.  
  1643.         return 1;
  1644.         }
  1645.     }
  1646.  
  1647.     switch (iocbp->ioc_cmd)
  1648.     {
  1649.     case ADVISE_STATUS:
  1650.         {
  1651.         int *status;
  1652.         caddr_t arg = *(caddr_t *)mp->b_cont->b_rptr;
  1653.  
  1654.         freemsg(mp->b_cont);
  1655.  
  1656.         mp->b_cont = allocb(sizeof(int), BPRI_MED);
  1657.         if (!mp->b_cont)
  1658.         {
  1659.         mp->b_datap->db_type = M_IOCNAK;
  1660.         freemsg(unlinkb(mp));
  1661.         iocbp->ioc_count = 0;
  1662.         iocbp->ioc_rval = 0;
  1663.         iocbp->ioc_error = ENOMEM;
  1664.         putnext(RD(q), mp);
  1665.         return 1;
  1666.         }
  1667.  
  1668.         status = (int *)mp->b_cont->b_rptr;
  1669.         mp->b_cont->b_wptr += sizeof(int);
  1670.  
  1671.         *status = sp->status;
  1672.  
  1673.         if (mp->b_datap->db_type == M_IOCTL &&
  1674.         iocbp->ioc_count == TRANSPARENT)
  1675.         {
  1676.         struct copyreq *creq = (struct copyreq *)mp->b_rptr;
  1677.         mp->b_datap->db_type = M_COPYOUT;
  1678.         creq->cq_addr = arg;
  1679.         mp->b_wptr = mp->b_rptr + sizeof *creq;
  1680.         mp->b_cont->b_wptr = mp->b_cont->b_rptr + sizeof(int);
  1681.         creq->cq_size = sizeof(int);
  1682.         creq->cq_flag = 0;
  1683.         creq->cq_private = (mblk_t *)NULL;
  1684.         putnext(RD(q), mp);
  1685.         return 1;
  1686.         }
  1687.     }
  1688.     break;
  1689.  
  1690.     case ADVISE_ALLOW:
  1691.     sp->status |= ALLOW_ADVICE;
  1692.  
  1693.     mp->b_datap->db_type = M_IOCACK;
  1694.     mp1 = unlinkb(mp);
  1695.     if (mp1)
  1696.         freeb(mp1);
  1697.     iocbp->ioc_count = 0;
  1698.     putnext(RD(q), mp);
  1699.     break;
  1700.  
  1701.     case ADVISE_DENY:
  1702.     sp->status &= ~(ALLOW_ADVICE);
  1703.  
  1704.     mp->b_datap->db_type = M_IOCACK;
  1705.     mp1 = unlinkb(mp);
  1706.     if (mp1)
  1707.         freeb(mp1);
  1708.     iocbp->ioc_count = 0;
  1709.     putnext(RD(q), mp);
  1710.     break;
  1711.  
  1712.     default:
  1713.     return 0;
  1714.     }
  1715.  
  1716.     return 1;
  1717. }
  1718. SHAR_EOF
  1719. fi # end of overwriting check
  1720. if test -f 'advisemod.h'
  1721. then
  1722.     echo shar: will not over-write existing file "'advisemod.h'"
  1723. else
  1724. cat << \SHAR_EOF > 'advisemod.h'
  1725. /* Copyright (C) 1990 Keith Gabryelski (ag@amix.commodore.com)
  1726.  
  1727. This file is part of advise.
  1728.  
  1729. advise is distributed in the hope that it will be useful,
  1730. but WITHOUT ANY WARRANTY.  No author or distributor
  1731. accepts responsibility to anyone for the consequences of using it
  1732. or for whether it serves any particular purpose or works at all,
  1733. unless he says so in writing.  Refer to the advise General Public
  1734. License for full details.
  1735.  
  1736. Everyone is granted permission to copy, modify and redistribute
  1737. advise, but only under the conditions described in the
  1738. advise General Public License.   A copy of this license is
  1739. supposed to have been given to you along with advise so you
  1740. can know your rights and responsibilities.  It should be in a
  1741. file named COPYING.  Among other things, the copyright notice
  1742. and this notice must be preserved on all copies.  */
  1743.  
  1744. /*
  1745. ** Author:    Keith Gabryelski    (ag@amix.commodore.com)
  1746. */
  1747.  
  1748. struct advise_queue_list
  1749. {
  1750.     mblk_t            *savbp;    /* ptr to this mblk for freeb()ing */
  1751.     queue_t            *q;    /* advisor's queue */
  1752.     int                minord; /* minor device for this advisor */
  1753.     struct advise_state        *state; /* ptr back to advise_state struct */
  1754.     struct advise_queue_list    *next;  /* ptr to next advisor */
  1755. };
  1756.  
  1757. struct advise_state
  1758. {
  1759.     mblk_t            *savbp;    /* ptr to this mblk for freeb()ing */
  1760.     int                status;    /* current status */
  1761.     dev_t            dev;    /* our device */
  1762.     queue_t            *q;    /* queue for advisor writing */
  1763.     struct advise_queue_list    *q_list;/* list of spies */
  1764.     struct advise_state        *next;  /* next in advise_table */
  1765. };
  1766.  
  1767. #define ALLOW_ADVICE        (0x01)
  1768.  
  1769. struct advise_message
  1770. {
  1771.     int                type;   /* What type of data is this? */
  1772. };
  1773.  
  1774. #define ADVISE_DATA        (0x00)
  1775. #define ADVISE_READDATA        (0x01)
  1776.  
  1777. #define ADVISE            ('z'<<16)
  1778. #define ADVISE_SETADVISEE    (ADVISE|0x01)
  1779. #define    ADVISE_ALLOW        (ADVISE|0x02)
  1780. #define    ADVISE_DENY        (ADVISE|0x03)
  1781. #define ADVISE_STATUS        (ADVISE|0x04)
  1782.  
  1783. #define spladvise    spltty
  1784. SHAR_EOF
  1785. fi # end of overwriting check
  1786. #    End of shell archive
  1787. exit 0
  1788.