home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / compsrcs / unix / volume04 / telnetd < prev    next >
Encoding:
Internet Message Format  |  1988-09-11  |  40.7 KB
  1. From: talcott!topaz!hedrick (Charles Hedrick)
  2. Subject: telnetd in the kernel
  3. Newsgroups: mod.sources
  4. Approved: jpn@panda.UUCP
  5.  
  6. Mod.sources:  Volume 4, Issue 90
  7. Submitted by: talcott!topaz!hedrick (Charles Hedrick)
  8.  
  9. [ I haven't tried any of this - you're on your own - mod ]
  10.  
  11. This is a modified version of the posting a couple of weeks ago by
  12. nyit!rick.  The original one moved the performance-critical part of
  13. rlogin into the kernel.  My version handles both rlogin and telnet.
  14. Note however, that it handles only the server part.  In our
  15. environment, many users have lines connected to terminal servers that
  16. speak Telnet.  We would like to be able to have a machine all of whose
  17. users are coming in via Telnet.  I am much less concerned about
  18. outgoing Telnet.  (After all, we can just hit BREAK and open another
  19. sesssion.  Why run Telnet on a host?)  Tests on a Pyramid 90X suggest
  20. that typing a file at 9600 baud via telnet uses a large fraction of
  21. the CPU.  Not all of that shows up in ps, but in vmstat, some extra
  22. system overhead show up.  Not only does telnet eat your CPU, but it is
  23. also more sensitive to load than it might be.  That is, under heavy
  24. load, you not only have to worry about your Emacs getting paged out.
  25. Your telnetd will also get delayed.  By moving telnetd into the
  26. kernel, the CPU usage is dramatically decreased.  I haven't done any
  27. really careful tests, but it appears that typing a file at 9600 baud
  28. uses 20% of the CPU briefly while buffers get filled, and less than
  29. 10% thereafter.  (I can't be sure.  It could be as low as 5%.)  More
  30. importantly, it makes your connection feel like a local terminal,
  31. assuming that your telnet user process is not adding any delay.
  32.  
  33. Rick's original code was quite simple, because rlogin is quite simple.
  34. rlogind simply does a magic IOCTL which causes the kernel to
  35. crosspatch the incoming network connection to the pty.  It stays that
  36. way until the user logs out or the connection goes away.
  37. Unfortunately, it is not practical to implement Telnet entirely in the
  38. kernel.  Telnet has things called "negotiations".  These allow one end
  39. to ask the other to turn off echoing, go into binary mode, and any of
  40. a number of wierder options.  These, and a few other Telnet commands,
  41. are all preceeded by an IAC character (decimal 255).  If you actually
  42. type an IAC character on your terminal, your telnet process will send
  43. two IAC's, so that it doesn't look like a negotiation.  This means
  44. that telnetd must scan the network for IAC's.  When it finds one, it
  45. must interpret the resulting command.  It must also scan the terminal
  46. output from the pty.  If it finds any IAC's, it must add an extra IAC,
  47. so that the result is seen by the other end as an IAC character,
  48. rather than a command.  It is reasonable to do the output processing
  49. in the kernel.  But it is not reasonable to do the input processing.
  50. So when my code sees an IAC in incoming data, it simply breaks the
  51. link and returns from the IOCTL.  The daemon reads the command, does
  52. whatever it needs to do, and then returns to the kernel with the
  53. IOCTL.  The IOCTL used to pass fd's for the network and pty to be
  54. crosspatched.  I now add 8-bit modes in the high-order end of the
  55. argument, one for the input side and one for the output side.  0 gives
  56. you rlogin.  1 gives you normal telnet.  2 gives you telnet binary
  57. (which currently is implemented only for input, just as in 4.2
  58. telnetd).
  59.  
  60. Some caveats about this code:
  61.   1) the kernel code is well tested.  So is rlogind.  telnetd is
  62.     not well tested.  It works with Unix, TOPS-20, and Bridge
  63.     terminal servers.  However none of those things is able
  64.     to generate certain of the telnet commands.  For example,
  65.     there is a Telnet protocol command to delete the previous
  66.     character.  Rather than send a rubout character, your
  67.     telnet user process can send a system-independent delete
  68.     character telnet command.  None of the systems we use do this.
  69.     We all just hit rubout, or whatever your delete character
  70.     is currently set to.  If there is a bug in this code, it
  71.     should be a fairly simple typo, and be easy enough to fix.
  72.   2) the telnetd code will work only with the modified kernel.
  73.     Rick's original rlogin was designed so it reverts to normal
  74.     code if you run it on a kernel without his patches.  The
  75.     changes to telnetd were more extensive, so I did not do it.
  76.     Presumably my version of telnetd will coredump if run on
  77.     kernel without these patches.
  78.   3) the kernel code is intended to be functionally identical to
  79.     the telnetd on which it is modelled.  In particular, I have
  80.     not fixed the bug involving bare CR's.  (According to the
  81.     telnet spec, if CR is not followed by LF, the server is
  82.     required to insert a NUL after the CR.  4.2 Telnet does
  83.     not do this.  Neither does my code.  All of the Telnet
  84.     user programs that we know about can handle CR's followed
  85.     by other things.  Implementing this would have taken more
  86.     time than I had to devote to the project.)
  87.   4) this code has been tested only on a Pyramid 90X.  It should work
  88.     unchanged with any release 3.0 Pyramid single-processor system.
  89.     The changes for a VAX should be fairly simple.  Actually, the
  90.     only one I know of is in nvs_output.  On the Pyramid, you
  91.     output something to the network by asking the network code
  92.     for some space, using sbnext.  This returns you a pointer.
  93.     You copy your data to the place pointed to.  You then do
  94.     tcp_usrreq(PRU_SEND ....  Apparently, on the VAX, things
  95.     work a bit differently.  You allocate an mbuf, copy the
  96.     data into the mbuf, and then pass the mbuf as an argument
  97.     to tcp_usrreq.  There are comments in nvs_output that suggest
  98.     what the code should probably look like, but I make no
  99.     guarantees.  To find it, search for the string "VAX" in
  100.     tty_nvs.c.  I believe that Pyramid operating system releases
  101.     older than 3.0 should be treated like a VAX.  To be sure,
  102.     find the code in tcp_usrreq that implements PRU_SEND.
  103.     (Just search for "case PRU_SEND" in ../netinet/tcp_usrreq.c.)
  104.     If that case contains a call to sbappend, then treat it like
  105.     a VAX.)
  106.   5) This code has not been symmetrized.  It will not run on a
  107.     Pyramid dual-processor system.  I think I know how to symmetrize
  108.     it.  But since I don't (yet) have a dual-processor machine, 
  109.     I have no way to test it.
  110.   6) in tty_nvs.c, set the flag NFS depending upon whether you have
  111.     Sun's NVS in your kernel.  Or if your compilation process
  112.     defines NFS externally, just remove the #define.
  113.  
  114. Even if you are not using telnet, you might want to look at this
  115. code.  I have improved rick's code in two major ways:
  116.   1) the original code used "busy waits" in the output code.
  117.     That is, when the network had enough data, the code would
  118.     dismiss for N milliseconds.  Every N msec it would check
  119.     to see if it was ready for more data.  I have added a
  120.     hook into sbwakeup, so that the code gets awakened when
  121.     there is more space.  It doesn't have to keep reactivating
  122.     and checking.
  123.   2) the original code has a table which gives the associations
  124.     between pty's and network connections.  If you have a
  125.     network connection and need to find the pty it goes to,
  126.     it does a linear search of that table.  I have added
  127.     a short to the socket buffer, and put the table index
  128.     into it.  This eliminates the search.  If you are not
  129.     using a Pyramid, make sure that this change to socketvar.h
  130.     isn't going to change the struct in some disasterous way.
  131.     It happened that on the Pyramid, there was a free short
  132.     in the place where I added that field.  If your compiler
  133.     allocates fields differently, it may not be free for you.
  134.  
  135. The rest of this posting consists of two pieces: a bunch of diffs to
  136. existing files, and a new file, tty_nvs.c.  If you have a Pyramid, you
  137. should modify .../conf/makefromsource (a simple makefile) to cause
  138. tty_nvs.c to be compiled and linked into the kernel.  I have no idea
  139. what you do on other machines.
  140.  
  141. *** ../conf/conf.c.HOLD    Thu Feb  6 00:13:04 1986
  142. --- ../conf/conf.c    Sun Apr 20 01:24:41 1986
  143. ***************
  144. *** 354,359
  145.   int    ptcopen(),ptcclose(),ptcread(),ptcwrite(),ptcselect();
  146.   int    ptyioctl(), ptsselect();
  147.   struct    tty pt_tty[];
  148.   #else
  149.   #define ptsopen        nodev
  150.   #define ptsclose    nodev
  151.  
  152. --- 354,361 -----
  153.   int    ptcopen(),ptcclose(),ptcread(),ptcwrite(),ptcselect();
  154.   int    ptyioctl(), ptsselect();
  155.   struct    tty pt_tty[];
  156. + struct socket *ptynvsso[NPTY];
  157. + int ptyoutmode[NPTY];
  158.   #else
  159.   #define ptsopen        nodev
  160.   #define ptsclose    nodev
  161. *** tty_pty.c.HOLD    Tue Aug 27 01:46:18 1985
  162. --- tty_pty.c    Sun Apr 20 04:45:42 1986
  163. ***************
  164. *** 26,31
  165.   extern int npty;    /* declared in conf.c */
  166.   extern struct    tty pt_tty[];
  167.   
  168.   /* NOTE: the following declaration is also make in conf.c
  169.        Keep the two in sync (should be put in a .h file somewhere) */
  170.   
  171.  
  172. --- 26,35 -----
  173.   extern int npty;    /* declared in conf.c */
  174.   extern struct    tty pt_tty[];
  175.   
  176. + #include "../h/socketvar.h"
  177. + extern struct socket *ptynvsso[];   /* socket indexed by pty minor dev# */
  178. +             /* decl in conf.c, so no dependence on NPTYS here */
  179. + 
  180.   /* NOTE: the following declaration is also make in conf.c
  181.        Keep the two in sync (should be put in a .h file somewhere) */
  182.   
  183. ***************
  184. *** 787,792
  185.       }
  186.       return (error);
  187.   }
  188.   
  189.   /*
  190.    * select routine for slave -- handles PF_REMOTE modes and PF_EOT states.
  191.  
  192. --- 791,837 -----
  193.       }
  194.       return (error);
  195.   }
  196. + 
  197. + /*
  198. +  * Transfer characters from NVS tty outq to associated socket
  199. +  * (Simply a jacket because timeout() accepts only 1 argument).
  200. +  *
  201. +  * Called at or below network IPL
  202. +  */
  203. + ptsnvsnet(tp)
  204. +     struct tty *tp;
  205. + {
  206. +     nvs_output(tp, &pt_ioctl[minor(tp->t_dev)].pt_send);
  207. + }
  208. + 
  209. + /*
  210. +  * Alternate t_oproc routine used when the pty is operating as an NVS
  211. +  */
  212. + ptsnvsstart(tp)
  213. +     register struct tty *tp;
  214. + {
  215. +     register int s;
  216. + 
  217. +     s = spl5();
  218. +     /*
  219. +      * TS_BUSY set means Ptsnvsnet() is either running or queued to run
  220. +      */
  221. +     if ((tp->t_state & TS_BUSY) == 0) {
  222. +         tp->t_state |= TS_BUSY;
  223. +         /*
  224. +          * If at low IPL, can make output happen now;
  225. +          * otherwise must sequence it through softclock
  226. +          */
  227. +         if (s == 0) {
  228. +             (void) spl0();        /* reduce IPL */
  229. +             nvs_output(tp, &pt_ioctl[minor(tp->t_dev)].pt_send);
  230. +         }
  231. +         else
  232. +             timeout(ptsnvsnet, (caddr_t)tp, 0);
  233. +     }
  234. +     splx(s);
  235. + }
  236. + 
  237.   
  238.   /*
  239.    * select routine for slave -- handles PF_REMOTE modes and PF_EOT states.
  240. *** uipc_socket2.c.HOLD    Tue Dec 10 19:57:26 1985
  241. --- uipc_socket2.c    Sun Apr 20 23:58:22 1986
  242. ***************
  243. *** 326,331
  244.       register struct sockbuf *sb;
  245.   {
  246.   
  247.       if (sb->sb_sel) {
  248.           selwakeup(sb->sb_sel, sb->sb_flags & SB_COLL);
  249.           sb->sb_sel = 0;
  250.  
  251. --- 326,340 -----
  252.       register struct sockbuf *sb;
  253.   {
  254.   
  255. +     if (sb->sb_flags & SB_NVS) {
  256. +         nvs_input(sb);
  257. +         return;
  258. +     }
  259. +     if (sb->sb_flags & SB_NVS_WAIT) {
  260. +       if (sbspace(sb) >= sb->sb_lowat)
  261. +         nvs_output_wake(sb);
  262. +       return;
  263. +     }
  264.       if (sb->sb_sel) {
  265.           selwakeup(sb->sb_sel, sb->sb_flags & SB_COLL);
  266.           sb->sb_sel = 0;
  267. *** ../netinet/tcp_usrreq.c.HOLD    Sat Apr 19 02:13:50 1986
  268. --- ../netinet/tcp_usrreq.c    Sat Apr 19 03:25:37 1986
  269. ***************
  270. *** 28,33
  271.   #include "../netinet/tcpip.h"
  272.   #include "../netinet/tcp_debug.h"
  273.   
  274.   /*
  275.    * TCP protocol interface to socket abstraction.
  276.    */
  277.  
  278. --- 28,35 -----
  279.   #include "../netinet/tcpip.h"
  280.   #include "../netinet/tcp_debug.h"
  281.   
  282. + #include "../h/ioctl.h"
  283. + 
  284.   /*
  285.    * TCP protocol interface to socket abstraction.
  286.    */
  287. ***************
  288. *** 220,225
  289.   
  290.   /* SOME AS YET UNIMPLEMENTED HOOKS */
  291.       case PRU_CONTROL:
  292.           error = EOPNOTSUPP;
  293.           break;
  294.   
  295.  
  296. --- 222,234 -----
  297.   
  298.   /* SOME AS YET UNIMPLEMENTED HOOKS */
  299.       case PRU_CONTROL:
  300. +         if ((int)m == SIOCJNVS) {
  301. +             if (tp->t_state == TCPS_ESTABLISHED)
  302. +                 error = nvs_ioc_join(so, *(int *)nam);
  303. +             else
  304. +                 error = ENOTCONN;
  305. +             break;
  306. +         }
  307.           error = EOPNOTSUPP;
  308.           break;
  309.   
  310. *** ioctl.h.HOLD    Thu Feb  6 01:03:11 1986
  311. --- ioctl.h    Thu Feb  6 01:03:11 1986
  312. ***************
  313. *** 394,399
  314.   #define    SIOCATMARK    _IOR(s,  7, int)        /* at oob mark? */
  315.   #define    SIOCSPGRP    _IOW(s,  8, int)        /* set process group */
  316.   #define    SIOCGPGRP    _IOR(s,  9, int)        /* get process group */
  317.   
  318.   #define    SIOCADDRT    _IOW(r, 10, struct rtentry)    /* add route */
  319.   #define    SIOCDELRT    _IOW(r, 11, struct rtentry)    /* delete route */
  320.  
  321. --- 394,400 -----
  322.   #define    SIOCATMARK    _IOR(s,  7, int)        /* at oob mark? */
  323.   #define    SIOCSPGRP    _IOW(s,  8, int)        /* set process group */
  324.   #define    SIOCGPGRP    _IOR(s,  9, int)        /* get process group */
  325. + #define SIOCJNVS    _IOW(s, 71, int)        /* join NVS pty&socket */
  326.   
  327.   #define    SIOCADDRT    _IOW(r, 10, struct rtentry)    /* add route */
  328.   #define    SIOCDELRT    _IOW(r, 11, struct rtentry)    /* delete route */
  329. *** socketvar.h.HOLD    Fri Dec  6 15:08:43 1985
  330. --- socketvar.h    Fri Dec  6 15:08:43 1985
  331. ***************
  332. *** 45,50
  333.           struct    mbuf *sb_mb;    /* the mbuf chain */
  334.           struct    proc *sb_sel;    /* process selecting read/write */
  335.           short    sb_flags;    /* flags, see below */
  336.       } so_rcv, so_snd;
  337.   #define    SB_LOCK        0x01        /* lock on data queue (so_rcv only) */
  338.   #define    SB_WANT        0x02        /* someone is waiting to lock */
  339.  
  340. --- 45,55 -----
  341.           struct    mbuf *sb_mb;    /* the mbuf chain */
  342.           struct    proc *sb_sel;    /* process selecting read/write */
  343.           short    sb_flags;    /* flags, see below */
  344. + /*
  345. +  * the following is gross, but if the comment above is right, we can't
  346. +  * add real pointer because it would make the structure too long
  347. +  */
  348. +         short    sb_nvs_index;    /* index into nvs data */
  349.       } so_rcv, so_snd;
  350.   #define    SB_LOCK        0x01        /* lock on data queue (so_rcv only) */
  351.   #define    SB_WANT        0x02        /* someone is waiting to lock */
  352. ***************
  353. *** 53,58
  354.   #define    SB_COLL        0x10        /* collision selecting */
  355.   #define SB_WAIT_SINGLE  0x20        /* someone waiting to lock (but only 
  356.                          wakeup 1 process when available) */
  357.       short    so_timeo;        /* connection timeout */
  358.       u_short    so_error;        /* error affecting connection */
  359.       short    so_oobmark;        /* chars to oob mark */
  360.  
  361. --- 58,65 -----
  362.   #define    SB_COLL        0x10        /* collision selecting */
  363.   #define SB_WAIT_SINGLE  0x20        /* someone waiting to lock (but only 
  364.                          wakeup 1 process when available) */
  365. + #define SB_NVS        0x40        /* socket crossbarred to NVS pty */
  366. + #define SB_NVS_WAIT    0x80        /* waiting for output buffer space */
  367.       short    so_timeo;        /* connection timeout */
  368.       u_short    so_error;        /* error affecting connection */
  369.       short    so_oobmark;        /* chars to oob mark */
  370. *** /src/usr.etc/in.telnetd.c.ORIG    Thu Oct 31 21:26:44 1985
  371. --- /src/usr.etc/in.telnetd.c    Sun Apr 20 06:06:04 1986
  372. ***************
  373. *** 52,58
  374.    */
  375.   char    ptyibuf[BUFSIZ], *ptyip = ptyibuf;
  376.   char    ptyobuf[BUFSIZ], *pfrontp = ptyobuf, *pbackp = ptyobuf;
  377. ! char    netibuf[BUFSIZ], *netip = netibuf;
  378.   char    netobuf[BUFSIZ], *nfrontp = netobuf, *nbackp = netobuf;
  379.   int    pcc, ncc;
  380.   
  381.  
  382. --- 54,60 -----
  383.    */
  384.   char    ptyibuf[BUFSIZ], *ptyip = ptyibuf;
  385.   char    ptyobuf[BUFSIZ], *pfrontp = ptyobuf, *pbackp = ptyobuf;
  386. ! unsigned char    netibuf[BUFSIZ], *netip = netibuf;
  387.   char    netobuf[BUFSIZ], *nfrontp = netobuf, *nbackp = netobuf;
  388.   int    pcc, ncc;
  389.   
  390. ***************
  391. *** 62,67
  392.   extern    int errno;
  393.   char    line[] = "/dev/ptyp0";
  394.   int    childsid;
  395.   
  396.   main(argc, argv)
  397.       char *argv[];
  398.  
  399. --- 64,70 -----
  400.   extern    int errno;
  401.   char    line[] = "/dev/ptyp0";
  402.   int    childsid;
  403. + char    remotehost[256];
  404.   
  405.   main(argc, argv)
  406.       char *argv[];
  407. ***************
  408. *** 140,145
  409.           host = hp->h_name;
  410.       else
  411.           host = ntoa(who->sin_addr);
  412.   
  413.       /* We identify who this is from. All of our children will
  414.        * inherit this id from us.
  415.  
  416. --- 143,149 -----
  417.           host = hp->h_name;
  418.       else
  419.           host = ntoa(who->sin_addr);
  420. +     strcpy(remotehost,host);
  421.   
  422.       /* We identify who this is from. All of our children will
  423.        * inherit this id from us.
  424. ***************
  425. *** 204,209
  426.   {
  427.       int on = 1;
  428.       char hostname[32];
  429.   
  430.       net = f, pty = p;
  431.       ioctl(f, FIONBIO, &on);
  432.  
  433. --- 208,214 -----
  434.   {
  435.       int on = 1;
  436.       char hostname[32];
  437. +     int arg;
  438.   
  439.       net = f, pty = p;
  440.       ioctl(f, FIONBIO, &on);
  441. ***************
  442. *** 220,227
  443.        * Show banner that getty never gave.
  444.        */
  445.       gethostname(hostname, sizeof (hostname));
  446. !     sprintf(nfrontp, BANNER, hostname, "");
  447. !     nfrontp += strlen(nfrontp);
  448.       for (;;) {
  449.           int ibits = 0, obits = 0;
  450.           register int c;
  451.  
  452. --- 225,233 -----
  453.        * Show banner that getty never gave.
  454.        */
  455.       gethostname(hostname, sizeof (hostname));
  456. !     sprintf(netobuf, BANNER, hostname, "");
  457. !     write(net,netobuf,strlen(netobuf));
  458. ! 
  459.       for (;;) {
  460.           register int c;
  461.   
  462. ***************
  463. *** 223,229
  464.       sprintf(nfrontp, BANNER, hostname, "");
  465.       nfrontp += strlen(nfrontp);
  466.       for (;;) {
  467. -         int ibits = 0, obits = 0;
  468.           register int c;
  469.   
  470.           /*
  471.  
  472. --- 229,234 -----
  473.       write(net,netobuf,strlen(netobuf));
  474.   
  475.       for (;;) {
  476.           register int c;
  477.   
  478.           if (myopts[TELOPT_BINARY])
  479. ***************
  480. *** 226,237
  481.           int ibits = 0, obits = 0;
  482.           register int c;
  483.   
  484. !         /*
  485. !          * Never look for input if there's still
  486. !          * stuff in the corresponding output buffer
  487. !          */
  488. !         if (nfrontp - nbackp || pcc > 0)
  489. !             obits |= (1 << f);
  490.           else
  491.               ibits |= (1 << p);
  492.           if (pfrontp - pbackp || ncc > 0)
  493.  
  494. --- 231,238 -----
  495.       for (;;) {
  496.           register int c;
  497.   
  498. !         if (myopts[TELOPT_BINARY])
  499. !           arg = 2 << 24;
  500.           else
  501.             arg = 1 << 24;
  502.           arg |= 1 << 16;
  503. ***************
  504. *** 233,250
  505.           if (nfrontp - nbackp || pcc > 0)
  506.               obits |= (1 << f);
  507.           else
  508. !             ibits |= (1 << p);
  509. !         if (pfrontp - pbackp || ncc > 0)
  510. !             obits |= (1 << p);
  511. !         else
  512. !             ibits |= (1 << f);
  513. !         if (ncc < 0 && pcc < 0)
  514. !             break;
  515. !         select(16, &ibits, &obits, 0, 0);
  516. !         if (ibits == 0 && obits == 0) {
  517. !             sleep(5);
  518. !             continue;
  519. !         }
  520.   
  521.           /*
  522.            * Something to read from the network...
  523.  
  524. --- 234,242 -----
  525.           if (myopts[TELOPT_BINARY])
  526.             arg = 2 << 24;
  527.           else
  528. !           arg = 1 << 24;
  529. !         arg |= 1 << 16;
  530. !         arg |= p;
  531.   
  532.           if (ioctl(f, SIOCJNVS, (char *)&arg) == -1)
  533.             cleanup();
  534. ***************
  535. *** 246,264
  536.               continue;
  537.           }
  538.   
  539. !         /*
  540. !          * Something to read from the network...
  541. !          */
  542. !         if (ibits & (1 << f)) {
  543. !             ncc = read(f, netibuf, BUFSIZ);
  544. !             if (ncc < 0 && errno == EWOULDBLOCK)
  545. !                 ncc = 0;
  546. !             else {
  547. !                 if (ncc <= 0)
  548. !                     break;
  549. !                 netip = netibuf;
  550. !             }
  551. !         }
  552.   
  553.           /*
  554.            * Something to read from the pty...
  555.  
  556. --- 238,245 -----
  557.           arg |= 1 << 16;
  558.           arg |= p;
  559.   
  560. !         if (ioctl(f, SIOCJNVS, (char *)&arg) == -1)
  561. !           cleanup();
  562.   
  563.           ncc = read(f, netibuf, BUFSIZ);
  564.           if (ncc <= 0)
  565. ***************
  566. *** 260,293
  567.               }
  568.           }
  569.   
  570. !         /*
  571. !          * Something to read from the pty...
  572. !          */
  573. !         if (ibits & (1 << p)) {
  574. !             pcc = read(p, ptyibuf, BUFSIZ);
  575. !             if (pcc < 0 && errno == EWOULDBLOCK)
  576. !                 pcc = 0;
  577. !             else {
  578. !                 if (pcc <= 0)
  579. !                     break;
  580. !                 ptyip = ptyibuf;
  581. !             }
  582. !         }
  583. ! 
  584. !         while (pcc > 0) {
  585. !             if ((&netobuf[BUFSIZ] - nfrontp) < 2)
  586. !                 break;
  587. !             c = *ptyip++ & 0377, pcc--;
  588. !             if (c == IAC)
  589. !                 *nfrontp++ = c;
  590. !             *nfrontp++ = c;
  591. !         }
  592. !         if ((obits & (1 << f)) && (nfrontp - nbackp) > 0)
  593. !             netflush();
  594. !         if (ncc > 0)
  595. !             telrcv();
  596. !         if ((obits & (1 << p)) && (pfrontp - pbackp) > 0)
  597. !             ptyflush();
  598.       }
  599.       cleanup();
  600.   }
  601.  
  602. --- 241,252 -----
  603.           if (ioctl(f, SIOCJNVS, (char *)&arg) == -1)
  604.             cleanup();
  605.   
  606. !         ncc = read(f, netibuf, BUFSIZ);
  607. !         if (ncc <= 0)
  608. !           {syslog(7,"in.telnetd ncc=%d, %d, %m",ncc,errno);
  609. !            break;
  610. !          }
  611. !         telrcv();
  612.       }
  613.       syslog(7,"in.telnetd from %s terminated: %m",remotehost);
  614.       cleanup();
  615. ***************
  616. *** 289,294
  617.           if ((obits & (1 << p)) && (pfrontp - pbackp) > 0)
  618.               ptyflush();
  619.       }
  620.       cleanup();
  621.   }
  622.       
  623.  
  624. --- 248,254 -----
  625.            }
  626.           telrcv();
  627.       }
  628. +     syslog(7,"in.telnetd from %s terminated: %m",remotehost);
  629.       cleanup();
  630.   }
  631.       
  632. ***************
  633. *** 310,315
  634.       register int c;
  635.       static int state = TS_DATA;
  636.       struct sgttyb b;
  637.   
  638.       while (ncc > 0) {
  639.           if ((&ptyobuf[BUFSIZ] - pfrontp) < 2)
  640.  
  641. --- 270,276 -----
  642.       register int c;
  643.       static int state = TS_DATA;
  644.       struct sgttyb b;
  645. +     struct auxchars aux;
  646.   
  647.       netip = netibuf;
  648.       while (ncc > 0) {
  649. ***************
  650. *** 311,316
  651.       static int state = TS_DATA;
  652.       struct sgttyb b;
  653.   
  654.       while (ncc > 0) {
  655.           if ((&ptyobuf[BUFSIZ] - pfrontp) < 2)
  656.               return;
  657.  
  658. --- 272,278 -----
  659.       struct sgttyb b;
  660.       struct auxchars aux;
  661.   
  662. +     netip = netibuf;
  663.       while (ncc > 0) {
  664.           c = *netip++ & 0377, ncc--;
  665.           switch (state) {
  666. ***************
  667. *** 312,319
  668.       struct sgttyb b;
  669.   
  670.       while (ncc > 0) {
  671. -         if ((&ptyobuf[BUFSIZ] - pfrontp) < 2)
  672. -             return;
  673.           c = *netip++ & 0377, ncc--;
  674.           switch (state) {
  675.   
  676.  
  677. --- 274,279 -----
  678.   
  679.       netip = netibuf;
  680.       while (ncc > 0) {
  681.           c = *netip++ & 0377, ncc--;
  682.           switch (state) {
  683.   
  684. ***************
  685. *** 322,332
  686.                   state = TS_IAC;
  687.                   break;
  688.               }
  689. !             if (inter > 0)
  690. !                 break;
  691. !             *pfrontp++ = c;
  692. !             if (!myopts[TELOPT_BINARY] && c == '\r')
  693. !                 state = TS_CR;
  694.               break;
  695.   
  696.           case TS_CR:
  697.  
  698. --- 282,289 -----
  699.                   state = TS_IAC;
  700.                   break;
  701.               }
  702. !             ptyobuf[0] = c;
  703. !             write(pty,ptyobuf,1);
  704.               break;
  705.   
  706.           case TS_IAC:
  707. ***************
  708. *** 329,340
  709.                   state = TS_CR;
  710.               break;
  711.   
  712. -         case TS_CR:
  713. -             if (c && c != '\n')
  714. -                 *pfrontp++ = c;
  715. -             state = TS_DATA;
  716. -             break;
  717. - 
  718.           case TS_IAC:
  719.               switch (c) {
  720.   
  721.  
  722. --- 286,291 -----
  723.               write(pty,ptyobuf,1);
  724.               break;
  725.   
  726.           case TS_IAC:
  727.               switch (c) {
  728.   
  729. ***************
  730. *** 352,358
  731.                * Are You There?
  732.                */
  733.               case AYT:
  734. !                 *nfrontp++ = BELL;
  735.                   break;
  736.   
  737.               /*
  738.  
  739. --- 303,311 -----
  740.                * Are You There?
  741.                */
  742.               case AYT:
  743. !    /* This assumes the Maryland ^T code is installed.
  744. !     * If not, you can following the original and
  745. !        * do ptyobuf[0] = BELL
  746. !        */
  747. !                 ioctl(pty, TIOCGAUXC, &aux);
  748. !                 ptyobuf[0] = aux.t_usest;
  749. !                 write(pty,ptyobuf,1);
  750.                   break;
  751.   
  752.               /*
  753. ***************
  754. *** 361,367
  755.                */
  756.               case EC:
  757.               case EL:
  758. -                 ptyflush();    /* half-hearted */
  759.                   ioctl(pty, TIOCGETP, &b);
  760.                   *pfrontp++ = (c == EC) ?
  761.                       b.sg_erase : b.sg_kill;
  762.  
  763. --- 314,319 -----
  764.                */
  765.               case EC:
  766.               case EL:
  767.                   ioctl(pty, TIOCGETP, &b);
  768.                   ptyobuf[0] = (c == EC) ?
  769.                       b.sg_erase : b.sg_kill;
  770. ***************
  771. *** 363,369
  772.               case EL:
  773.                   ptyflush();    /* half-hearted */
  774.                   ioctl(pty, TIOCGETP, &b);
  775. !                 *pfrontp++ = (c == EC) ?
  776.                       b.sg_erase : b.sg_kill;
  777.                   break;
  778.   
  779.  
  780. --- 315,321 -----
  781.               case EC:
  782.               case EL:
  783.                   ioctl(pty, TIOCGETP, &b);
  784. !                 ptyobuf[0] = (c == EC) ?
  785.                       b.sg_erase : b.sg_kill;
  786.                   write(pty,ptyobuf,1);
  787.                   break;
  788. ***************
  789. *** 365,370
  790.                   ioctl(pty, TIOCGETP, &b);
  791.                   *pfrontp++ = (c == EC) ?
  792.                       b.sg_erase : b.sg_kill;
  793.                   break;
  794.   
  795.               /*
  796.  
  797. --- 317,323 -----
  798.                   ioctl(pty, TIOCGETP, &b);
  799.                   ptyobuf[0] = (c == EC) ?
  800.                       b.sg_erase : b.sg_kill;
  801. +                 write(pty,ptyobuf,1);
  802.                   break;
  803.   
  804.               /*
  805. ***************
  806. *** 388,394
  807.                   continue;
  808.   
  809.               case IAC:
  810. !                 *pfrontp++ = c;
  811.                   break;
  812.               }
  813.               state = TS_DATA;
  814.  
  815. --- 341,348 -----
  816.                   continue;
  817.   
  818.               case IAC:
  819. !                 ptyobuf[0] = IAC;
  820. !                 write(pty,ptyobuf,1);
  821.                   break;
  822.               }
  823.               state = TS_DATA;
  824. ***************
  825. *** 424,431
  826.           case TS_DONT:
  827.               if (myopts[c]) {
  828.                   myopts[c] = 0;
  829. !                 sprintf(nfrontp, wont, c);
  830. !                 nfrontp += sizeof (wont) - 2;
  831.               }
  832.               state = TS_DATA;
  833.               continue;
  834.  
  835. --- 378,385 -----
  836.           case TS_DONT:
  837.               if (myopts[c]) {
  838.                   myopts[c] = 0;
  839. !                 sprintf(netobuf, wont, c);
  840. !                 write(net,netobuf,sizeof (wont) - 2);
  841.               }
  842.               state = TS_DATA;
  843.               continue;
  844. ***************
  845. *** 434,439
  846.               printf("telnetd: panic state=%d\n", state);
  847.               exit(1);
  848.           }
  849.       }
  850.   }
  851.   
  852.  
  853. --- 388,403 -----
  854.               printf("telnetd: panic state=%d\n", state);
  855.               exit(1);
  856.           }
  857. +     if ((state != TS_DATA) && (ncc <= 0)) {
  858. +       int ibits;
  859. + 
  860. +       ibits = 1 << net;
  861. +       select(1,&ibits,0,0,0);
  862. +       ncc = read(net, netibuf, BUFSIZ);
  863. +       if (ncc <= 0)
  864. +         {syslog(7,"in.telnetd ncc=%d, %d, %m",ncc,errno);
  865. +          cleanup();
  866. +        }
  867.       }
  868.             }
  869.   }
  870. ***************
  871. *** 435,440
  872.               exit(1);
  873.           }
  874.       }
  875.   }
  876.   
  877.   willoption(option)
  878.  
  879. --- 399,405 -----
  880.            cleanup();
  881.          }
  882.       }
  883. +           }
  884.   }
  885.   
  886.   willoption(option)
  887. ***************
  888. *** 466,472
  889.           fmt = dont;
  890.           break;
  891.       }
  892. !     sprintf(nfrontp, fmt, option);
  893.       nfrontp += sizeof (dont) - 2;
  894.   }
  895.   
  896.  
  897. --- 431,437 -----
  898.           fmt = dont;
  899.           break;
  900.       }
  901. !     sprintf(netobuf, fmt, option);
  902.       nfrontp += sizeof (dont) - 2;
  903.   }
  904.   
  905. ***************
  906. *** 527,533
  907.           break;
  908.       }
  909.       sprintf(nfrontp, fmt, option);
  910. !     nfrontp += sizeof (doopt) - 2;
  911.   }
  912.   
  913.   mode(on, off)
  914.  
  915. --- 492,498 -----
  916.           break;
  917.       }
  918.       sprintf(nfrontp, fmt, option);
  919. !     write(net, nfrontp, sizeof (doopt) - 2);
  920.   }
  921.   
  922.   mode(on, off)
  923. *** /src/etc/in.rlogind.c.ORIG    Sat Aug  3 20:53:22 1985
  924. --- /src/etc/in.rlogind.c    Sat Apr 19 07:10:27 1986
  925. ***************
  926. *** 148,153
  927.           ioctl(p, TIOCPKT, &on);
  928.           signal(SIGTSTP, SIG_IGN);
  929.           signal(SIGCHLD, cleanup);
  930.           for (;;) {
  931.               int ibits = 0, obits = 0;
  932.   
  933.  
  934. --- 150,170 -----
  935.           ioctl(p, TIOCPKT, &on);
  936.           signal(SIGTSTP, SIG_IGN);
  937.           signal(SIGCHLD, cleanup);
  938. +         /* BEGIN NVS support */
  939. +         /*
  940. +          * If kernel supports high-performance NVS operation,
  941. +          * invoke it and sleep until connection is broken.
  942. +          * If remote end dies: ioctl() returns 0.
  943. +          * If local job exits: ioctl() returns -1 / EINTR.
  944. +          * Any other return from ioctl() is interpreted to mean
  945. +          * the kernel doesn't support high-performance NVS
  946. +          * operation, so do the job the standard Berkeley way.
  947. +          */
  948. +         if (ioctl(f, SIOCJNVS, (char *)&p) == 0 ||
  949. +             errno == EINTR)
  950. +             cleanup();
  951. +         /* END NVS support */
  952.           for (;;) {
  953.               int ibits = 0, obits = 0;
  954.   
  955.  
  956. ****** new file: ../sys/tty_nvs.c ********
  957.  
  958. /*
  959.  * Network virtual terminals via sockets - server end
  960.  *
  961.  *    Rick Ace
  962.  *    New York Institute of Technology
  963.  *    Computer Graphics Laboratory
  964.  *    Old Westbury, New York  11568
  965.  */
  966.  
  967. /*
  968.  * The code in this module supports the NVS, or remote end of the connection
  969.  * (i.e., the link between the network and the pseudo-terminal).
  970.  * The purpose of this code is to emulate efficiently the character-
  971.  * shuffling functions performed by /etc/rlogind.  The rlogin on the other
  972.  * host will believe it is talking to rlogind, when it is in reality
  973.  * talking to the NVS kernel software herein.
  974.  *
  975.  * The NVS kernel software achieves performance improvements by handling
  976.  * incoming character traffic at interrupt level, eliminating the overhead
  977.  * and delays resulting from scheduling a user-mode process (rlogind).
  978.  * Outgoing character traffic is dumped directly into the socket by
  979.  * Ptsnvsstart() in tty_pty.c, further eliminating the need for service
  980.  * by a user-mode process.
  981.  *
  982.  * The implementation is broken into two main layers:
  983.  *    1)  high-level software, common to all NVSs (nvs_XXX subrs) 
  984.  *    2)  protocol-specific stuff (tcp_XXX, etc.) 
  985.  * Presently, there is only a TCP implementation for layer # 2.
  986.  */
  987.  
  988. #define NFS 1
  989.  
  990. #include "../h/param.h"
  991. #include "../h/conf.h"
  992. #include "../h/dir.h"
  993. #include "../h/user.h"
  994. #include "../h/proc.h"        /* for lint */
  995. #include "../h/file.h"
  996. #include "../h/tty.h"
  997. #include "../h/mbuf.h"
  998. #include "../h/protosw.h"
  999. #include "../h/socketvar.h"
  1000. #ifdef NFS
  1001. #include "../h/vnode.h"
  1002. #include "../ufs/inode.h"
  1003. #else NFS
  1004. #include "../h/inode.h"
  1005. #endif NFS
  1006.  
  1007. #define nvs_emsg    printf
  1008.  
  1009. #define MAXNVS    32        /* should be in a parameter file */
  1010.  
  1011. /*
  1012.  * tp-to-socket correspondence table.
  1013.  *
  1014.  * This table is searched linearly.  A highest-entry mark is maintained
  1015.  * to keep search overhead low.  If there is a need to support large
  1016.  * numbers of NVSs, the linear search should be replaced by hashing.
  1017.  */
  1018. struct nvsj {
  1019.     struct tty    *nvs_tp;    /* tty/pty context, or 0 if free */
  1020.     struct socket    *nvs_so;    /* socket context */
  1021.     int        nvs_in_mode;    /* input side mode */
  1022. } nvsj[MAXNVS + 1];
  1023.  
  1024. /* in modes */
  1025.  
  1026. #define IN_RLOGIN    0        /* no processing */
  1027. #define IN_TELNET    1        /* telnet, normal */
  1028. #define IN_BINARY    2        /* telnet binary */
  1029. #define IN_CR        3        /* cr seen in nonbinary */
  1030.  
  1031. /* out modes */
  1032.  
  1033. #define OUT_RLOGIN    0        /* special urgent mode stuff */
  1034. #define OUT_TELNET    1        /* special IAC processing */
  1035.  
  1036. /* currently this is not implemented */
  1037.  
  1038. #define IAC        255
  1039.  
  1040. struct nvsj    *nvshij = &nvsj[0];    /* highest active entry */
  1041.  
  1042. #ifndef lint
  1043. int    nvsj_n = MAXNVS;        /* for kernel debug utilities */
  1044. #endif
  1045.  
  1046. int    nvsichz;
  1047.  
  1048. extern struct socket *ptynvsso[ /* NPTY */ ]; /* socket indexed by pty minor */
  1049. extern int ptyoutmode[ /* NPTY */ ];
  1050.  
  1051. int    ptsstart(), ptsnvsstart(), ptsnvsnet();
  1052.  
  1053. /*
  1054.  * Mate a tty and a socket
  1055.  *
  1056.  * Returns UNIX error code
  1057.  * Must be called at splimp
  1058.  */
  1059. nvs_add(tp, so, anvs, inmode, outmode)
  1060.     struct tty *tp;
  1061.     struct socket *so;
  1062.     struct nvsj **anvs;    /* return addr of NVS context here */
  1063.     int inmode, outmode;
  1064. {
  1065.     register struct nvsj *nvs, *nx;
  1066.     extern int hz;                /* XXX */
  1067.  
  1068.     if (nvsichz == 0) 
  1069.         nvsichz = hz / 3;        /* XXX */
  1070.     if (tp->t_oproc != ptsstart) 
  1071.         return ENOTTY;        /* not a pty or not in right mode */
  1072.     nvs = 0;
  1073.     nx = &nvsj[MAXNVS - 1];
  1074.     do {
  1075.         if (nx->nvs_tp) {
  1076.             if (nx->nvs_tp == tp || nx->nvs_so == so) {
  1077.                 return EBUSY; /* tty or socket already an NVS */
  1078.                   }
  1079.         }
  1080.         else
  1081.             nvs = nx;    /* remember lowest empty slot */
  1082.     } while (--nx >= &nvsj[0]);
  1083.     if (nvs == 0) {
  1084.         return ENFILE;        /* all slots are in use */
  1085.           }
  1086.     /*
  1087.      * All is clear, mate them
  1088.      */
  1089.     if (nvs > nvshij) 
  1090.         nvshij = nvs;        /* update highest active entry */
  1091.     *anvs = nvs;            /* pass context pointer to caller */
  1092.     nvs->nvs_so = so;
  1093.     nvs->nvs_in_mode = inmode;
  1094.     nvs->nvs_tp = tp;
  1095.     so->so_rcv.sb_flags |= SB_NVS;
  1096.     so->so_rcv.sb_nvs_index = nvs - nvsj;
  1097.     so->so_snd.sb_nvs_index = nvs - nvsj;
  1098.     tp->t_oproc = ptsnvsstart;
  1099.     ptyoutmode[minor(tp->t_dev)] = outmode;
  1100.     ptynvsso[minor(tp->t_dev)] = so;
  1101.     sbwakeup(&so->so_rcv);        /* get characters flowing */
  1102.     ptsnvsstart(tp);        /* ditto */
  1103.     return 0;
  1104. }
  1105.  
  1106. /*
  1107.  * Undo a tty/socket correspondence
  1108.  *
  1109.  * Must be called at splimp
  1110.  */
  1111. nvs_del(nvs)
  1112.     struct nvsj *nvs;
  1113. {
  1114.     register struct tty *tp;
  1115.  
  1116.     nvs->nvs_so->so_rcv.sb_flags &= ~SB_NVS;
  1117.     tp = nvs->nvs_tp;
  1118.     if (tp->t_oproc == ptsnvsstart) 
  1119.         tp->t_oproc = ptsstart;
  1120.     ptynvsso[minor(tp->t_dev)] = 0;
  1121.     /*
  1122.      * Delete this entry and adjust Nvshij if necessary
  1123.      */
  1124.     nvs->nvs_tp = 0;        /* mark entry as free */
  1125.     if (nvshij == nvs) 
  1126.         while (nvshij > &nvsj[0] && nvshij->nvs_tp == 0) 
  1127.             nvshij--;
  1128. }
  1129.  
  1130. /*
  1131.  * Called from sbwakeup() when NVS has incoming characters from the net,
  1132.  * to transfer those characters from the socket to the tty's input queue
  1133.  *
  1134.  * Logic here is similar to that of soreceive() in uipc_socket.c
  1135.  */
  1136. nvs_input(sb)
  1137.     struct sockbuf *sb;        /* so_rcv */
  1138. {
  1139. #define STRUCT_OFF(strnam, elem) \
  1140.     ((char *)&((struct strnam *)0)->elem - (char *)0) 
  1141.     register struct socket *so;
  1142.     register struct nvsj *nvs;
  1143.     register struct tty *tp;
  1144.     register struct mbuf *m;
  1145.     register unsigned char *cp;
  1146.     register int n;
  1147.     struct mbuf *mz;
  1148.     int nvsmode,xflags;
  1149.     unsigned char inchar;
  1150.  
  1151.     /*
  1152.      * Convert so_rcv address to socket address (a bit gross),
  1153.      * then search the active-connection table for that socket
  1154.      */
  1155.     so = (struct socket *)((char *)sb - STRUCT_OFF(socket, so_rcv));
  1156.     nvs = &nvsj[sb->sb_nvs_index];
  1157.     if ((tp = nvs->nvs_tp) == 0) {
  1158.       nvs_emsg("nvs input no tp %x\n", so);
  1159.       return;
  1160.     }
  1161.     nvsmode = nvs->nvs_in_mode;  /* flags. use a register for speed */
  1162.     xflags = tp->t_xflags;  /* Pyramid extra flags for ATT mode */
  1163.     /*
  1164.      * Have located the tty, now pass it the data
  1165.      */
  1166.     so->so_state &= ~SS_RCVATMARK;        /* ignore out-of-band data */
  1167.     so->so_oobmark = 0;            /* ditto */
  1168.     /*
  1169.      * Process each mbuf on the socket's rcv queue
  1170.      */
  1171.     while (so->so_rcv.sb_cc > 0) {
  1172.         m = so->so_rcv.sb_mb;
  1173.         if (m == 0) 
  1174.             panic("nvs_input");
  1175.         cp = mtod(m, unsigned char *);
  1176.         for (n = m->m_len; --n >= 0; ) {
  1177.               inchar = *cp++;
  1178.  
  1179.             switch (nvsmode) {
  1180.             case IN_CR: 
  1181.               nvsmode = IN_TELNET;
  1182.               if ((inchar == 0) || (inchar == '\n'))
  1183.                 break;
  1184.             case IN_TELNET:
  1185.               if (inchar == '\r')
  1186.                 nvsmode = IN_CR;
  1187.             case IN_BINARY:
  1188.               if (inchar == IAC) {
  1189.                 n = m->m_len - (n + 1);  /* chars read */
  1190.                 m->m_off += n;
  1191.                 so->so_rcv.sb_cc -= n;
  1192.                 m->m_len -= n;
  1193.                 so->so_rcv.sb_flags &= ~SB_NVS;
  1194.                 wakeup((caddr_t)nvs);
  1195.                 return;
  1196.               }
  1197.             case IN_RLOGIN:
  1198. /*
  1199.  * The code from here to the call to linesw is Pyramid-specific, because
  1200.  * of implementing ATT terminal handling
  1201.  */
  1202.             if (xflags&BTLON) {
  1203.                 inchar = inchar&0377;
  1204.                 
  1205.                 if (xflags&XISTRIP)
  1206.                     inchar &= 0177;
  1207.                 if ((inchar == '\n') && (xflags&XINLCR)) {
  1208.                     inchar = '\r';
  1209.                 } else if (inchar == '\r') {
  1210.                     if (xflags&XIGNCR) {
  1211.                         break;
  1212.                     } else if (xflags&XICRNL)
  1213.                         inchar = '\n';
  1214.                 }
  1215.                 if ((inchar >= 'A') &&
  1216.                     (inchar <= 'Z') &&
  1217.                     (xflags&XIUCLC))
  1218.                         inchar |= 040;
  1219.             }
  1220.               (*linesw[tp->t_line].l_rint)(inchar, tp);
  1221.             }
  1222.               }
  1223.         sbfree(&so->so_rcv, m);
  1224.         MFREE(m, mz);
  1225.         so->so_rcv.sb_mb = m = mz;
  1226.     }
  1227.     nvs->nvs_in_mode = nvsmode;  /* put back possibly changed flags */
  1228.     /*
  1229.      * Notify protocol that more space is available in the socket
  1230.      */
  1231.     if ((so->so_state & SS_CANTRCVMORE) == 0 &&
  1232.         so->so_proto->pr_flags & PR_WANTRCVD &&
  1233.         so->so_pcb) 
  1234.         (*so->so_proto->pr_usrreq)(so, PRU_RCVD,
  1235.             (struct mbuf *)0, (struct mbuf *)0, (struct mbuf *)0);
  1236.     /*
  1237.      * If socket closes at remote end first (not the most common case),
  1238.      * wake up the agent process so it can exit.
  1239.      */
  1240.     if (so->so_state & (SS_CANTRCVMORE | SS_CANTSENDMORE)) {
  1241.         so->so_rcv.sb_flags &= ~SB_NVS;
  1242.         wakeup((caddr_t)nvs);
  1243.     }
  1244. }
  1245.  
  1246. /*
  1247.  * Handle ioctl request on socket to join socket and pty, called
  1248.  * from protocol ioctl logic.  Protocol-specific validation is
  1249.  * done before you get here.
  1250.  *
  1251.  * If the connection was successfully established, sleep and wait
  1252.  * until it is broken at the remote end, or until a signal is
  1253.  * received on the local end.
  1254.  *
  1255.  * Returns
  1256.  *    0 = remote NVT closed the connection
  1257.  *    EINTR = interrupted by signal
  1258.  *    Anything else = an error establishing the connection
  1259.  */
  1260. nvs_ioc_join(so, ptyfd)
  1261.     struct socket *so;
  1262.     int ptyfd;        /* pty file descriptor */
  1263. {
  1264.     register struct file *fp;
  1265.     register struct inode *ip;
  1266.     register struct tty *tp;
  1267.     int error, s;
  1268.     struct nvsj *nvsp;
  1269.     int ptcopen();
  1270.     int inmode, outmode;
  1271.  
  1272.     outmode = (ptyfd >> 16) & 0xFF;
  1273.     inmode = ptyfd >> 24;
  1274.     ptyfd = ptyfd & 0xFFFF;
  1275.  
  1276.     /*
  1277.      * Validate file descriptor and ensure it references a pty
  1278.      */
  1279.     if ((unsigned)ptyfd >= NOFILE || (fp = u.u_ofile[ptyfd]) == 0) 
  1280.         return EBADF;
  1281. #ifdef NFS
  1282.     {
  1283.         register struct vnode *vp;
  1284.  
  1285.         vp = (struct vnode *)fp->f_data;
  1286.         if (fp->f_type != DTYPE_VNODE || vp->v_op != &ufs_vnodeops) 
  1287.             return ENOTTY;
  1288.         ip = VTOI(vp);
  1289.         if ((ip->i_mode & IFMT) != IFCHR ||
  1290.             cdevsw[major(ip->i_rdev)].d_open != ptcopen) 
  1291.             return ENOTTY;        /* really ENOTPTY :-) */
  1292.     }
  1293. #else NFS
  1294.     ip = (struct inode *)fp->f_data;
  1295.     if (fp->f_type != DTYPE_INODE ||
  1296.         (ip->i_mode & IFMT) != IFCHR ||
  1297.         cdevsw[major(ip->i_rdev)].d_open != ptcopen) 
  1298.         return ENOTTY;        /* really ENOTPTY :-) */
  1299. #endif NFS
  1300.     /*
  1301.      * Argument socket and pty are valid, now join them and wait
  1302.      */
  1303.     tp = cdevsw[major(ip->i_rdev)].d_ttys;
  1304.     s = splimp();
  1305.     if (error = nvs_add(tp + minor(ip->i_rdev), so, &nvsp, 
  1306.                 inmode, outmode)) {
  1307.         splx(s);
  1308.         return error;
  1309.     }
  1310.     if (setjmp(&u.u_qsave)) {
  1311.         /*
  1312.          * The process received a signal
  1313.          */
  1314.         nvs_del(nvsp);        /* disassociate pty&socket */
  1315.         splx(s);
  1316.         return EINTR;
  1317.     }
  1318.     while (nvsp->nvs_so->so_rcv.sb_flags & SB_NVS)
  1319.       sleep((caddr_t)nvsp, PZERO + 1); /* wait for signal or disconnect */
  1320.  
  1321.     /*
  1322.      * The remote disconnected.
  1323.      */
  1324.     nvs_del(nvsp);            /* disassociate pty&socket */
  1325.     splx(s);
  1326.     return 0;
  1327. }
  1328.  
  1329. /*
  1330.  * nvs_output_wake is called from sbwakeup when more space becomes
  1331.  * available in the socket output buffer.  The code that clears
  1332.  * SB_NVS_WAIT assumes that this is called at iplnet.  Let's hope
  1333.  * it is.
  1334.  */
  1335.  
  1336. nvs_output_wake(sb)
  1337.     struct sockbuf *sb;        /* so_snd */
  1338. {
  1339.     register struct socket *so;
  1340.     register struct nvsj *nvs;
  1341.     register struct tty *tp;
  1342.  
  1343.     nvs = &nvsj[sb->sb_nvs_index];
  1344.     if ((tp = nvs->nvs_tp) == 0) {
  1345.       nvs_emsg("nvs output wake no tp %x\n", sb);
  1346.       return;
  1347.     }
  1348.     sb->sb_flags &= ~(SB_NVS_WAIT | SB_WAIT);
  1349.     ptsnvsnet(tp);  /* calls nvs_output immediately */
  1350.       }
  1351.  
  1352. /*
  1353.  * Move characters from pty outq to network
  1354.  * TS_BUSY is assumed to be set upon entry
  1355.  *
  1356.  * Must be called at or below net IPL
  1357.  */
  1358. /*ARGSUSED*/
  1359. nvs_output(tp, urgentp)
  1360.     struct tty *tp;
  1361.     int *urgentp;        /* call by reference because I can zero it */
  1362. {
  1363.       register struct mbuf *m;
  1364.     register struct socket *so;
  1365.     register int error, s, space;
  1366.     unsigned char * dp;
  1367.     int outmode;
  1368.     int iacs,chars;
  1369.  
  1370.     s = splnet();
  1371.     if ((so = ptynvsso[minor(tp->t_dev)]) == 0) {    /* paranoid */
  1372.         /*
  1373.          * no longer an NVS!
  1374.          */
  1375.         statemask(tp,~TS_BUSY);
  1376.         if (tp->t_oproc) 
  1377.             (*tp->t_oproc)(tp);
  1378.         goto rspl;
  1379.     }
  1380.     if (so->so_state & SS_CANTSENDMORE) {
  1381.         while (getc(&tp->t_outq) >= 0) 
  1382.             ;
  1383.         *urgentp = 0;
  1384.     }
  1385.     outmode = ptyoutmode[minor(tp->t_dev)];
  1386.     /*
  1387.      * If there is urgent data to send, ship it now
  1388.      */
  1389.     if (*urgentp && (outmode == OUT_RLOGIN)) {
  1390.           MGET(m, M_DONTWAIT, MT_DATA);
  1391.         if (m == 0) 
  1392.           goto out;
  1393.  
  1394.         *mtod(m, unsigned char *) = *urgentp;
  1395.         *urgentp = 0;
  1396.         m->m_len = 1;
  1397.         error = (*so->so_proto->pr_usrreq)(so,
  1398.             PRU_SENDOOB, m, (struct mbuf *)0, (struct mbuf *)0);
  1399.         if (error) 
  1400.             nvs_emsg("nvs SENDOOB %d\n", error);
  1401.         goto out;
  1402.     }
  1403.     else *urgentp = 0;
  1404.     if ((tp->t_state & TS_TTSTOP) && (outmode != OUT_RLOGIN)) {
  1405.       spl5();
  1406.       statemask(tp,~TS_BUSY);
  1407.       goto out2;
  1408.     }
  1409.     while (tp->t_outq.c_cc > 0) {
  1410.         /*
  1411.          * Send a chunk of character traffic that may be pending
  1412.          */
  1413.       /*
  1414.        * We check for space in the socket first, because the most
  1415.        * common wait is due to flow control from the other end.
  1416.        * Since we are using a form of busy wait, we want to detect
  1417.        * this as soon as possible
  1418.        */
  1419.       space = sbspace(&so->so_snd);
  1420.       if (space < so->so_snd.sb_lowat) { /* not enough space */
  1421.         so->so_snd.sb_flags |= SB_NVS_WAIT | SB_WAIT; /* wait till space */
  1422.         spl5();  /* needed at out2 */
  1423.         goto out2;  /* don't resched.  net code will call us when space */
  1424.       }
  1425.       /*
  1426.        * Each time through the loop we do one contiguous piece of
  1427.        * data from the character list.  We have to do it this way
  1428.        * in order to be able to check for iacs efficiently.
  1429.        */
  1430.       iacs = 0;
  1431.       chars = ndqb(&tp->t_outq,0);
  1432.  
  1433.       if (outmode != OUT_RLOGIN) { /* look for IAC's */
  1434.         int count;
  1435.         unsigned char * cp = (unsigned char *)tp->t_outq.c_cf;
  1436.         
  1437.         for (count = chars; count > 0; count--)
  1438.           if (*cp++ == IAC)
  1439.         iacs++;
  1440.       }
  1441. /*
  1442.  * at this point chars is number of chars in first piece of buffer,
  1443.  * and iacs is number of iacs in that 
  1444.  */
  1445.  
  1446. /*
  1447.  *  The following code is specific to Pyramid release 3.0
  1448.  *  We are trying to copy data from the pty buffer out to the
  1449.  *  network.  On the Pyramid, sbnext is used to find where to
  1450.  *  copy the data to.  It returns (in dp) a pointer into an
  1451.  *  mbuf.  If there was already data on the queue, this is
  1452.  *  a pointer into an existing mbuf.  If not, it allocates a
  1453.  *  new one.  It returns the amount of space left in the mbuf.
  1454.  *  It sets m_len in the mbuf assuming that you are actually
  1455.  *  going to put that much data in.
  1456.  *
  1457.  *  On a VAX, things work differently.  Instead of calling
  1458.  *  sbnext to find a place to put your data, you allocate
  1459.  *  an mbuf yourself.  Then you copy the data into it as
  1460.  *  below.  Further down, you will find a call to pr_usrreq.
  1461.  *  On a VAX, the argument I have given as "1" would be the
  1462.  *  mbuf.  The second line below, with sbnext in it, and the
  1463.  *  following two lines, "if (space <= 0) goto out;", should
  1464.  *  probably be replaced by
  1465.  *    MGET(m, M_DONTWAIT, MT_DATA);
  1466.  *    if (m == 0) 
  1467.  *        goto out;
  1468.  *    if (space > MLEN) 
  1469.  *        space = MLEN;
  1470.  *    dp = mtod(m, unsigned char *);
  1471.  *      m->m_len = space;
  1472.  *  This effectively simulates sbnext, although in a somewhat
  1473.  *  less intelligent way than Pyramid's actual code.
  1474.  *  In the call to pr_usrreq below, you should probably change
  1475.  *  the argument "1" to "m".
  1476.  */
  1477.       space = MIN(space, chars + iacs);
  1478.       space = sbnext(&so->so_snd,&dp,space);
  1479.       if (space <= 0)
  1480.         goto out;  /* no mbufs. this does a busy wait until space */
  1481. /*
  1482.  * This is an optimization.  If there are no IAC's, we can just copy
  1483.  * the data from the pty directly into the tcp mbuf.  If there are
  1484.  * IAC's, we have to turn each single IAC into two IAC's.  We do
  1485.  * this by copying one character at a time.  If we decide to turn bare
  1486.  * CR into CR NUL, as required by the spec, we will have to do something
  1487.  * similar when we find a bare CR.  We will also have to remember when
  1488.  * the last character we process is a CR, for handling next time around.
  1489.  */
  1490.       if (iacs == 0) {
  1491.         q_to_b(&tp->t_outq, dp, space);
  1492.         so->so_snd.sb_cc += space;
  1493.       }
  1494.       else {
  1495.         int count = space;
  1496.         while (count-- > 1) { /* leave one extra for iac */
  1497.           unsigned char outchar;
  1498.           outchar = getc(&tp->t_outq);
  1499.           *dp++ = outchar;
  1500.           if (outchar == IAC) {
  1501.         *dp++ = outchar;
  1502.         count--;
  1503.           }
  1504.         }
  1505.         so->so_snd.sb_mb->m_len -= count;  /* either 1 or 0 left over */
  1506.         so->so_snd.sb_cc += space - count;
  1507.       }
  1508.  
  1509.       error = (*so->so_proto->pr_usrreq)(so,
  1510.            PRU_SEND, 1, (struct mbuf *)0, (struct mbuf *)0);
  1511. #ifdef lint
  1512.         /* Same actuals as above, better information for lint */
  1513.       error = tcp_usrreq(so,
  1514.            PRU_SEND, 1, (struct mbuf *)0, (struct mbuf *)0);
  1515. #endif
  1516.     }
  1517.  
  1518.  
  1519. out:    /*
  1520.      * Perpetuate myself if work remains
  1521.      */
  1522.     (void) spl5();            /* block out tty activity */
  1523.     if (tp->t_outq.c_cc > 0 || *urgentp)
  1524.         timeout(ptsnvsnet, (caddr_t)tp, nvsichz); /* TS_BUSY remains set */
  1525.     else
  1526.         statemask(tp,~TS_BUSY);
  1527. out2:    /*
  1528.      * Wake up sleepers
  1529.      */
  1530.     if (tp->t_outq.c_cc <= TTLOWAT(tp)) {
  1531.         if (tp->t_state&TS_ASLEEP) {
  1532.             statemask(tp,~TS_ASLEEP);
  1533.             wakeup((caddr_t)&tp->t_outq);
  1534.         }
  1535.         if (tp->t_wsel) {
  1536.             selwakeup(tp->t_wsel, tp->t_state & TS_WCOLL);
  1537.             tp->t_wsel = 0;
  1538.             statemask(tp,~TS_WCOLL);
  1539.         }
  1540.     }
  1541. rspl:    splx(s);
  1542. }
  1543.  
  1544.  
  1545.