开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 代理服务器 > 查看源码
sys_bsd.c
资源名称：socks5.zip　[点击查看]
上传用户：sddyfurun
上传日期：2007-01-04
资源大小：525k
文件大小：28k
源码类别：

代理服务器

开发平台：

Unix_Linux

sys_bsd.c：源码内容
  1. /* Copyright (c) 1988, 1990, 1993                                            */
  2. /* The Regents of the University of California.  All rights reserved.        */
  3. /*                                                                           */
  4. /* Redistribution and use in source and binary forms, with or without        */
  5. /* modification, are permitted provided that the following conditions        */
  6. /* are met:                                                                  */
  7. /* 1. Redistributions of source code must retain the above copyright         */
  8. /* notice, this list of conditions and the following disclaimer.             */
  9. /* 2. Redistributions in binary form must reproduce the above copyright      */
  10. /* notice, this list of conditions and the following disclaimer in the       */
  11. /* documentation and/or other materials provided with the distribution.      */
  12. /* 3. All advertising materials mentioning features or use of this           */
  13. /* software must display the following acknowledgement:                      */
  14. /*   This product includes software developed by the University of           */
  15. /*   California, Berkeley and its contributors.                              */
  16. /* 4. Neither the name of the University nor the names of its contributors   */
  17. /* may be used to endorse or promote products derived from this software     */
  18. /* without specific prior written permission.                                */
  19. /*                                                                           */
  20. /* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND   */
  21. /* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE     */
  22. /* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR        */
  23. /* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE */
  24. /* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR       */
  25. /* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF      */
  26. /* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS  */
  27. /* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN   */
  28. /* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)   */
  29. /* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF    */
  30. /* THE POSSIBILITY OF SUCH DAMAGE.                                           */
  32. #ifdef SHOW_SCCSIDS
  33. static char sccsid[] = "@(#)sys_bsd.c 8.4 (Berkeley) 5/30/95";
  34. #endif
  36. /* The following routines try to encapsulate what is system dependent        */
  37. /* (at least between 4.x and dos) which is used in telnet.c.                 */
  39. #include "config.h"
  40. #include <fcntl.h>
  41. #include <sys/types.h>
  42. #include <sys/time.h>
  43. #include <sys/socket.h>
  45. #ifdef HAVE_SYS_SELECT_H
  46. #include <sys/select.h>
  47. #endif
  49. #include <signal.h>
  50. #include <errno.h>
  51. #include <arpa/telnet.h>
  53. #include "ring.h"
  54. #include "fdset.h"
  55. #include "defines.h"
  56. #include "externs.h"
  57. #include "types.h"
  59. #define DONT_NEED_SIGBLOCK
  60. #define DONT_NEED_SIGUNBLOCK
  61. #define DONT_NEED_SIGPAUSE
  62. #define DONT_NEED_SIGPENDING
  63. #include "sigfix.h"
  65. extern RETSIGTYPE ayt_status(), ayt(), susp();
  67. int tout; /* Output file descriptor */
  68. int tin;  /* Input file descriptor */
  69. int net;
  71. #ifndef USE_TERMIO
  72. struct tchars otc = { 0 }, ntc = { 0 };
  73. struct ltchars oltc = { 0 }, nltc = { 0 };
  74. struct sgttyb ottyb = { 0 }, nttyb = { 0 };
  75. int olmode = 0;
  76. # define cfgetispeed(ptr) (ptr)->sg_ispeed
  77. # define cfgetospeed(ptr) (ptr)->sg_ospeed
  78. # define old_tc ottyb
  80. #else /* USE_TERMIO */
  81. struct termio old_tc = { 0 };
  82. extern struct termio new_tc;
  84. # ifndef TCSANOW
  85. #  ifdef TCSETS
  86. #   define TCSANOW TCSETS
  87. #   define TCSADRAIN TCSETSW
  88. #   define tcgetattr(f, t) ioctl(f, TCGETS, (char *)t)
  89. #  else
  90. #   ifdef TCSETA
  91. #    define TCSANOW TCSETA
  92. #    define TCSADRAIN TCSETAW
  93. #    define tcgetattr(f, t) ioctl(f, TCGETA, (char *)t)
  94. #   else
  95. #    define TCSANOW TIOCSETA
  96. #    define TCSADRAIN TIOCSETAW
  97. #    define tcgetattr(f, t) ioctl(f, TIOCGETA, (char *)t)
  98. #   endif
  99. #  endif
  100. #  define tcsetattr(f, a, t) ioctl(f, a, (char *)t)
  101. #  define cfgetospeed(ptr) ((ptr)->c_cflag&CBAUD)
  102. #  ifdef CIBAUD
  103. #   define cfgetispeed(ptr) (((ptr)->c_cflag&CIBAUD) >> IBSHIFT)
  104. #  else
  105. #   define cfgetispeed(ptr) cfgetospeed(ptr)
  106. #  endif
  107. # endif /* TCSANOW */
  108. # ifdef sysV88
  109. # define TIOCFLUSH TC_PX_DRAIN
  110. # endif
  111. #endif /* USE_TERMIO */
  113. static fd_set ibits, obits, xbits;
  115. void init_sys() {
  116.     tout = fileno(stdout);
  117.     tin  = fileno(stdin);
  119.     FD_ZERO(&ibits);
  120.     FD_ZERO(&obits);
  121.     FD_ZERO(&xbits);
  123.     errno = 0;
  124. }
  126. int TerminalWrite(unsigned char *buf, int n) {
  127.     return write(tout, buf, n);
  128. }
  130. int TerminalRead(unsigned char *buf, int n) {
  131.     return read(tin, buf, n);
  132. }
  134. int TerminalAutoFlush() {
  135. #ifdef LNOFLSH
  136.     int flush;
  138.     ioctl(0, TIOCLGET, (char *)&flush);
  139.     return !(flush & LNOFLSH); /* if LNOFLSH, no autoflush */
  140. #else
  141.     return 1;
  142. #endif
  143. }
  145. #ifdef KLUDGELINEMODE
  146. extern int kludgelinemode;
  147. #endif
  148. /* TerminalSpecialChars()                                                    */
  149. /*                                                                           */
  150. /* Look at an input character to see if it is a special character            */
  151. /* and decide what to do.                                                    */
  152. /*                                                                           */
  153. /* Output:                                                                   */
  154. /*  * 0 Don't add this character.                                            */
  155. /*  * 1 Do add this character                                                */
  156. extern void xmitAO(), xmitEL(), xmitEC(), intp(), sendbrk();
  158. int TerminalSpecialChars(int c) {
  159.     if (c == termIntChar) {
  160. intp();
  161. return 0;
  162.     } else if (c == termQuitChar) {
  163. #ifdef KLUDGELINEMODE
  164. if (kludgelinemode) sendbrk();
  165. else
  166. #endif
  167.     sendabort();
  168. return 0;
  169.     } else if (c == termEofChar) {
  170. if (my_want_state_is_will(TELOPT_LINEMODE)) {
  171.     sendeof();
  172.     return 0;
  173. }
  174. return 1;
  175.     } else if (c == termSuspChar) {
  176. sendsusp();
  177. return(0);
  178.     } else if (c == termFlushChar) {
  179. xmitAO(); /* Transmit Abort Output */
  180. return 0;
  181.     } else if (!MODE_LOCAL_CHARS(globalmode)) {
  182. if (c == termKillChar) {
  183.     xmitEL();
  184.     return 0;
  185. } else if (c == termEraseChar) {
  186.     xmitEC(); /* Transmit Erase Character */
  187.     return 0;
  188. }
  189.     }
  191.     return 1;
  192. }
  195. /* Flush output to the terminal                                              */
  196. void TerminalFlushOutput() {
  197. #ifdef TIOCFLUSH
  198.     ioctl(fileno(stdout), TIOCFLUSH, (char *) 0);
  199. #else
  200.     ioctl(fileno(stdout), TCFLSH, (char *) 0);
  201. #endif
  202. }
  204. void TerminalSaveState() {
  205. #ifndef USE_TERMIO
  206.     ioctl(0, TIOCGETP, (char *)&ottyb);
  207.     ioctl(0, TIOCGETC, (char *)&otc);
  208.     ioctl(0, TIOCGLTC, (char *)&oltc);
  209.     ioctl(0, TIOCLGET, (char *)&olmode);
  211.     ntc = otc;
  212.     nltc = oltc;
  213.     nttyb = ottyb;
  215. #else /* USE_TERMIO */
  216.     tcgetattr(0, &old_tc);
  217.     new_tc = old_tc;
  219. #ifndef VDISCARD
  220.     termFlushChar = CONTROL('O');
  221. #endif
  222. #ifndef VWERASE
  223.     termWerasChar = CONTROL('W');
  224. #endif
  225. #ifndef VREPRINT
  226.     termRprntChar = CONTROL('R');
  227. #endif
  228. #ifndef VLNEXT
  229.     termLiteralNextChar = CONTROL('V');
  230. #endif
  231. #ifndef VSTART
  232.     termStartChar = CONTROL('Q');
  233. #endif
  234. #ifndef VSTOP
  235.     termStopChar = CONTROL('S');
  236. #endif
  237. #ifndef VSTATUS
  238.     termAytChar = CONTROL('T');
  239. #endif
  240. #endif /* USE_TERMIO */
  241. }
  243. cc_t *tcval(register int func) {
  244.     switch(func) {
  245. case SLC_IP: return(&termIntChar);
  246. case SLC_ABORT: return(&termQuitChar);
  247. case SLC_EOF: return(&termEofChar);
  248. case SLC_EC: return(&termEraseChar);
  249. case SLC_EL: return(&termKillChar);
  250. case SLC_XON: return(&termStartChar);
  251. case SLC_XOFF: return(&termStopChar);
  252. case SLC_FORW1: return(&termForw1Char);
  253. #ifdef USE_TERMIO
  254. case SLC_FORW2: return(&termForw2Char);
  255. # ifdef VDISCARD
  256. case SLC_AO: return(&termFlushChar);
  257. # endif
  258. # ifdef VSUSP
  259. case SLC_SUSP: return(&termSuspChar);
  260. # endif
  261. # ifdef VWERASE
  262. case SLC_EW: return(&termWerasChar);
  263. # endif
  264. # ifdef VREPRINT
  265. case SLC_RP: return(&termRprntChar);
  266. # endif
  267. # ifdef VLNEXT
  268. case SLC_LNEXT: return(&termLiteralNextChar);
  269. # endif
  270. # ifdef VSTATUS
  271. case SLC_AYT: return(&termAytChar);
  272. # endif
  273. #endif
  274. case SLC_SYNCH:
  275. case SLC_BRK:
  276. case SLC_EOR:
  277. default:       return((cc_t *)0);
  278.     }
  279. }
  281. void TerminalDefaultChars() {
  282. #ifndef USE_TERMIO
  283.     ntc  = otc;
  284.     nltc = oltc;
  285.     nttyb.sg_kill  = ottyb.sg_kill;
  286.     nttyb.sg_erase = ottyb.sg_erase;
  287. #else /* USE_TERMIO */
  288.     memmove(new_tc.c_cc, old_tc.c_cc, sizeof(old_tc.c_cc));
  289. # ifndef VDISCARD
  290.     termFlushChar = CONTROL('O');
  291. # endif
  292. # ifndef VWERASE
  293.     termWerasChar = CONTROL('W');
  294. # endif
  295. # ifndef VREPRINT
  296.     termRprntChar = CONTROL('R');
  297. # endif
  298. # ifndef VLNEXT
  299.     termLiteralNextChar = CONTROL('V');
  300. # endif
  301. # ifndef VSTART
  302.     termStartChar = CONTROL('Q');
  303. # endif
  304. # ifndef VSTOP
  305.     termStopChar = CONTROL('S');
  306. # endif
  307. # ifndef VSTATUS
  308.     termAytChar = CONTROL('T');
  309. # endif
  310. #endif /* USE_TERMIO */
  311. }
  313. #ifdef notdef
  314. void TerminalRestoreState() 
  315. {
  316. }
  317. #endif
  319. /* TerminalNewMode - set up terminal to a specific mode.                     */
  320. /*  * MODE_ECHO: do local terminal echo                                      */
  321. /*  * MODE_FLOW: do local flow control                                       */
  322. /*  * MODE_TRAPSIG: do local mapping to TELNET IAC sequences                 */
  323. /*  * MODE_EDIT: do local line editing                                       */
  324. /*                                                                           */
  325. /*  Command mode:                                                            */
  326. /*  * MODE_ECHO|MODE_EDIT|MODE_FLOW|MODE_TRAPSIG                             */
  327. /*  * local echo                                                             */
  328. /*  * local editing                                                          */
  329. /*  * local xon/xoff                                                         */
  330. /*  * local signal mapping                                                   */
  331. /*                                                                           */
  332. /*  Linemode:                                                                */
  333. /*  * local/no editing                                                       */
  334. /*  * Both Linemode and Single Character mode:                               */
  335. /*  * local/remote echo                                                      */
  336. /*  * local/no xon/xoff                                                      */
  337. /*  * local/no signal mapping                                                */
  338. void TerminalNewMode(register int f) {
  339.     static int prevmode = 0;
  340. #ifndef USE_TERMIO
  341.     struct tchars tc;
  342.     struct ltchars ltc;
  343.     struct sgttyb sb;
  344.     int lmode;
  345. #else /* USE_TERMIO */
  346.     struct termio tmp_tc;
  347. #endif /* USE_TERMIO */
  348.     int onoff;
  349.     int old;
  350.     cc_t esc;
  352.     globalmode = f & ~MODE_FORCE;
  353.     if (prevmode == f)  return;
  355.     /* Write any outstanding data before switching modes ttyflush() returns  */
  356.     /* 0 only when there is no more data left to write out, it returns -1 if */
  357.     /* it couldn't do anything at all, otherwise it returns 1 + the number   */
  358.     /* of characters left to write.                                          */
  359. #ifndef USE_TERMIO
  360.     /* We would really like ask the kernel to wait for the output to drain,  */
  361.     /* like we can do with the TCSADRAIN, but we don't have that option.     */
  362.     /* The only ioctl that waits for the output to drain, TIOCSETP, also     */
  363.     /* flushes the input queue, which is NOT what we want (TIOCSETP is like  */
  364.     /* TCSADFLUSH).                                                          */
  365. #endif
  367.     old = ttyflush(SYNCHing|flushout);
  368.     if (old < 0 || old > 1) {
  370. #ifdef USE_TERMIO
  371. tcgetattr(tin, &tmp_tc);
  372. #endif
  374. /* Wait for data to drain, then flush again.                         */
  375. do {
  376. #ifdef USE_TERMIO
  377.     tcsetattr(tin, TCSADRAIN, &tmp_tc);
  378. #endif
  379.     old = ttyflush(SYNCHing|flushout);
  380. } while (old < 0 || old > 1);
  381.     }
  383.     old = prevmode;
  384.     prevmode = f&~MODE_FORCE;
  385. #ifndef USE_TERMIO
  386.     sb = nttyb;
  387.     tc = ntc;
  388.     ltc = nltc;
  389.     lmode = olmode;
  390. #else
  391.     tmp_tc = new_tc;
  392. #endif
  394.     if (f&MODE_ECHO) {
  395. #ifndef USE_TERMIO
  396. sb.sg_flags |= ECHO;
  397. #else
  398. tmp_tc.c_lflag |= ECHO;
  399. tmp_tc.c_oflag |= ONLCR;
  400. if (crlf) tmp_tc.c_iflag |= ICRNL;
  401. #endif
  402.     } else {
  403. #ifndef USE_TERMIO
  404. sb.sg_flags &= ~ECHO;
  405. #else
  406. tmp_tc.c_lflag &= ~ECHO;
  407. tmp_tc.c_oflag &= ~ONLCR;
  408. # ifdef notdef
  409. if (crlf) tmp_tc.c_iflag &= ~ICRNL;
  410. # endif
  411. #endif
  412.     }
  414.     if ((f&MODE_FLOW) == 0) {
  415. #ifndef USE_TERMIO
  416. tc.t_startc = _POSIX_VDISABLE;
  417. tc.t_stopc = _POSIX_VDISABLE;
  418. #else
  419. tmp_tc.c_iflag &= ~(IXOFF|IXON); /* Leave the IXANY bit alone */
  420.     } else {
  421. if (restartany < 0) {
  422. tmp_tc.c_iflag |= IXOFF|IXON; /* Leave the IXANY bit alone */
  423. } else if (restartany > 0) {
  424. tmp_tc.c_iflag |= IXOFF|IXON|IXANY;
  425. } else {
  426. tmp_tc.c_iflag |= IXOFF|IXON;
  427. tmp_tc.c_iflag &= ~IXANY;
  428. }
  429. #endif
  430.     }
  432.     if ((f&MODE_TRAPSIG) == 0) {
  433. #ifndef USE_TERMIO
  434. tc.t_intrc = _POSIX_VDISABLE;
  435. tc.t_quitc = _POSIX_VDISABLE;
  436. tc.t_eofc = _POSIX_VDISABLE;
  437. ltc.t_suspc = _POSIX_VDISABLE;
  438. ltc.t_dsuspc = _POSIX_VDISABLE;
  439. #else
  440. tmp_tc.c_lflag &= ~ISIG;
  441. #endif
  442. localchars = 0;
  443.     } else {
  444. #ifdef USE_TERMIO
  445. tmp_tc.c_lflag |= ISIG;
  446. #endif
  447. localchars = 1;
  448.     }
  450.     if (f&MODE_EDIT) {
  451. #ifndef USE_TERMIO
  452. sb.sg_flags &= ~CBREAK;
  453. sb.sg_flags |= CRMOD;
  454. #else
  455. tmp_tc.c_lflag |= ICANON;
  456. #endif
  457.     } else {
  458. #ifndef USE_TERMIO
  459. sb.sg_flags |= CBREAK;
  460. if (f&MODE_ECHO) sb.sg_flags |= CRMOD;
  461. else sb.sg_flags &= ~CRMOD;
  462. #else
  463. tmp_tc.c_lflag &= ~ICANON;
  464. tmp_tc.c_iflag &= ~ICRNL;
  465. tmp_tc.c_cc[VMIN] = 1;
  466. tmp_tc.c_cc[VTIME] = 0;
  467. #endif
  468.     }
  470.     if ((f&(MODE_EDIT|MODE_TRAPSIG)) == 0) {
  471. #ifndef USE_TERMIO
  472. ltc.t_lnextc = _POSIX_VDISABLE;
  473. #else
  474. # ifdef VLNEXT
  475. tmp_tc.c_cc[VLNEXT] = (cc_t)(_POSIX_VDISABLE);
  476. # endif
  477. #endif
  478.     }
  480.     if (f & MODE_SOFT_TAB) {
  481. #ifndef USE_TERMIO
  482. sb.sg_flags |= XTABS;
  483. #else
  484. # ifdef OXTABS
  485. tmp_tc.c_oflag |= OXTABS;
  486. # endif
  487. # ifdef TABDLY
  488. tmp_tc.c_oflag &= ~TABDLY;
  489. tmp_tc.c_oflag |= TAB3;
  490. # endif
  491. #endif
  492.     } else {
  493. #ifndef USE_TERMIO
  494. sb.sg_flags &= ~XTABS;
  495. #else
  496. # ifdef OXTABS
  497. tmp_tc.c_oflag &= ~OXTABS;
  498. # endif
  499. # ifdef TABDLY
  500. tmp_tc.c_oflag &= ~TABDLY;
  501. # endif
  502. #endif
  503.     }
  505. #ifndef USE_TERMIO
  506.     if (f & MODE_LIT_ECHO) lmode &= ~LCTLECH;
  507.     else                   lmode |= LCTLECH;
  508. #elif defined(ECHOCTL)
  509.     if (f & MODE_LIT_ECHO) tmp_tc.c_lflag &= ~ECHOCTL;
  510.     else                   tmp_tc.c_lflag |= ECHOCTL;
  511. #endif
  513.     if (f == -1) {
  514. onoff = 0;
  515.     } else {
  516. #ifndef USE_TERMIO
  517. if (f & MODE_OUTBIN) lmode |= LLITOUT;
  518. else                 lmode &= ~LLITOUT;
  520. if (f & MODE_INBIN)  lmode |= LPASS8;
  521. else                 lmode &= ~LPASS8;
  522. #else
  523. if (f & MODE_INBIN)  tmp_tc.c_iflag &= ~ISTRIP;
  524. else                 tmp_tc.c_iflag |= ISTRIP;
  526. if (f & MODE_OUTBIN) {
  527. tmp_tc.c_cflag &= ~(CSIZE|PARENB);
  528. tmp_tc.c_cflag |= CS8;
  529. tmp_tc.c_oflag &= ~OPOST;
  530. } else {
  531. tmp_tc.c_cflag &= ~(CSIZE|PARENB);
  532. tmp_tc.c_cflag |= old_tc.c_cflag & (CSIZE|PARENB);
  533. tmp_tc.c_oflag |= OPOST;
  534. }
  535. #endif
  536. onoff = 1;
  537.     }
  539.     if (f != -1) {
  540. #ifdef SIGTSTP
  541. Signal(SIGTSTP, susp);
  542. #endif
  543. #ifdef SIGINFO
  544. Signal(SIGINFO, ayt);
  545. #endif
  546. #if defined(USE_TERMIO) && defined(NOKERNINFO)
  547. tmp_tc.c_lflag |= NOKERNINFO;
  548. #endif
  549. /* We don't want to process ^Y here.  It's just another character    */
  550. /* that we'll pass on to the back end.  It has to process it because */
  551. /* it will be processed when the user attempts to read it, not when  */
  552. /* we send it.                                                       */
  553. #ifndef USE_TERMIO
  554. ltc.t_dsuspc = _POSIX_VDISABLE;
  555. #else
  556. # ifdef VDSUSP
  557. tmp_tc.c_cc[VDSUSP] = (cc_t)(_POSIX_VDISABLE);
  558. # endif
  559. #endif
  561. #ifdef USE_TERMIO
  562. /* If the VEOL character is already set, then use VEOL2, otherwise   */
  563. /* use VEOL.                                                         */
  564. esc = (rlogin != _POSIX_VDISABLE) ? rlogin : escape;
  565. if ((tmp_tc.c_cc[VEOL] != esc)
  566. # ifdef VEOL2
  567.     && (tmp_tc.c_cc[VEOL2] != esc)
  568. # endif
  569.     ) {
  570. if (tmp_tc.c_cc[VEOL] == (cc_t)(_POSIX_VDISABLE))
  571.     tmp_tc.c_cc[VEOL] = esc;
  572. # ifdef VEOL2
  573. else if (tmp_tc.c_cc[VEOL2] == (cc_t)(_POSIX_VDISABLE))
  574.     tmp_tc.c_cc[VEOL2] = esc;
  575. # endif
  576. }
  577. #else
  578. if (tc.t_brkc == (cc_t)(_POSIX_VDISABLE))
  579. tc.t_brkc = esc;
  580. #endif
  581.     } else {
  582. #ifdef SIGINFO
  583. Signal(SIGINFO, ayt_status);
  584. #endif
  585. #ifdef SIGTSTP
  586. Signal(SIGTSTP, SIG_DFL);
  587. # ifdef HAVE_SIGPROCMASK
  588. {
  589.     sigset_t tmask;
  590.     sigemptyset(&tmask);
  591.     sigaddset(&tmask, SIGTSTP);
  592.     sigprocmask(SIG_UNBLOCK, &tmask, (sigset_t*)0);
  593. }
  594. # else
  595. sigsetmask(sigblock(0) & ~(1<<(SIGTSTP-1)));
  596. # endif
  597. #endif
  598. #ifndef USE_TERMIO
  599. ltc = oltc;
  600. tc = otc;
  601. sb = ottyb;
  602. lmode = olmode;
  603. #else
  604. tmp_tc = old_tc;
  605. #endif
  606.     }
  607. #ifndef USE_TERMIO
  608.     ioctl(tin, TIOCLSET, (char *)&lmode);
  609.     ioctl(tin, TIOCSLTC, (char *)&ltc);
  610.     ioctl(tin, TIOCSETC, (char *)&tc);
  611.     ioctl(tin, TIOCSETN, (char *)&sb);
  612. #else
  613.     if (tcsetattr(tin, TCSADRAIN, &tmp_tc) < 0)
  614. tcsetattr(tin, TCSANOW, &tmp_tc);
  615. #endif
  617. #if ((!defined(TN3270)) || ((!defined(NOT43)) || defined(PUTCHAR))) && !defined(sysV88)
  618.     ioctl(tin,  FIONBIO, (char *)&onoff);
  619.     ioctl(tout, FIONBIO, (char *)&onoff);
  620. #endif
  622. #ifdef TN3270
  623.     if (noasynchtty == 0) {
  624. ioctl(tin, FIOASYNC, (char *)&onoff);
  625.     }
  626. #endif
  628. }
  630. /*
  631.  * Try to guess whether speeds are "encoded" (4.2BSD) or just numeric (4.4BSD).
  632.  */
  633. #if B4800 != 4800
  634. #define DECODE_BAUD
  635. #endif
  637. #ifdef DECODE_BAUD
  638. #ifndef B7200
  639. #define B7200   B4800
  640. #endif
  642. #ifndef B14400
  643. #define B14400  B9600
  644. #endif
  646. #ifndef B19200
  647. # define B19200 B14400
  648. #endif
  650. #ifndef B28800
  651. #define B28800  B19200
  652. #endif
  654. #ifndef B38400
  655. # define B38400 B28800
  656. #endif
  658. #ifndef B57600
  659. #define B57600  B38400
  660. #endif
  662. #ifndef B76800
  663. #define B76800  B57600
  664. #endif
  666. #ifndef B115200
  667. #define B115200 B76800
  668. #endif
  670. #ifndef B230400
  671. #define B230400 B115200
  672. #endif
  675. /*
  676.  * This code assumes that the values B0, B50, B75...
  677.  * are in ascending order.  They do not have to be
  678.  * contiguous.
  679.  */
  680. struct termspeeds {
  681. long speed;
  682. long value;
  683. } termspeeds[] = {
  684. { 0,      B0 },      { 50,    B50 },    { 75,     B75 },
  685. { 110,    B110 },    { 134,   B134 },   { 150,    B150 },
  686. { 200,    B200 },    { 300,   B300 },   { 600,    B600 },
  687. { 1200,   B1200 },   { 1800,  B1800 },  { 2400,   B2400 },
  688. { 4800,   B4800 },   { 7200,  B7200 },  { 9600,   B9600 },
  689. { 14400,  B14400 },  { 19200, B19200 }, { 28800,  B28800 },
  690. { 38400,  B38400 },  { 57600, B57600 }, { 115200, B115200 },
  691. { 230400, B230400 }, { -1,    B230400 }
  692. };
  693. #endif /* DECODE_BAUD */
  695. void TerminalSpeeds(long *ispeed, long *ospeed) {
  696. #ifdef DECODE_BAUD
  697.     register struct termspeeds *tp;
  698. #endif
  699.     register long in, out;
  700.     
  701.     out = cfgetospeed(&old_tc);
  702.     in  = cfgetispeed(&old_tc);
  703.     
  704.     if (in == 0) in = out;
  705.     
  706. #ifdef DECODE_BAUD
  707.     tp = termspeeds;
  708.     while ((tp->speed != -1) && (tp->value < in)) tp++;
  709.     *ispeed = tp->speed;
  710.     
  711.     tp = termspeeds;
  712.     while ((tp->speed != -1) && (tp->value < out)) tp++;
  713.     *ospeed = tp->speed;
  714. #else
  715.     *ispeed = in;
  716.     *ospeed = out;
  717. #endif
  718. }
  720. int TerminalWindowSize(long *rows, long *cols) {
  721. #ifdef TIOCGWINSZ
  722.     struct winsize ws;
  723.     
  724.     if (ioctl(fileno(stdin), TIOCGWINSZ, (char *)&ws) >= 0) {
  725. *rows = ws.ws_row;
  726. *cols = ws.ws_col;
  727. return 1;
  728.     }
  729. #endif
  730.     return 0;
  731. }
  733. int NetClose(int fd) {
  734.     return close(fd);
  735. }
  738. void NetNonblockingIO(int fd, int onoff) {
  739.     ioctl(fd, FIONBIO, (char *)&onoff);
  740. }
  742. #ifdef TN3270
  743. void NetSigIO(int fd, int onoff) {
  744.     /* hear about input */
  745.     ioctl(fd, FIOASYNC, (char *)&onoff);
  746. }
  748. void NetSetPgrp(int fd) {
  749.     int myPid;
  751.     myPid = getpid();
  752.     fcntl(fd, F_SETOWN, myPid);
  753. }
  754. #endif
  756. /* Various signal handling routines.                                         */
  758. RETSIGTYPE deadpeer(int sig) {
  759.     setcommandmode();
  760.     longjmp(peerdied, -1);
  761. }
  763. RETSIGTYPE intr(int sig) {
  764.     if (localchars) {
  765. intp();
  766. return;
  767.     }
  769.     setcommandmode();
  770.     longjmp(toplevel, -1);
  771. }
  773. RETSIGTYPE intr2(int sig) {
  774.     if (localchars) {
  775. #ifdef KLUDGELINEMODE
  776. if (kludgelinemode) sendbrk();
  777. else
  778. #endif
  779. sendabort();
  780. return;
  781.     }
  782. }
  784. #ifdef SIGTSTP
  785. RETSIGTYPE susp(int sig) {
  786.     if ((rlogin != _POSIX_VDISABLE) && rlogin_susp()) return;
  787.     if (localchars) sendsusp();
  788. }
  789. #endif
  791. #ifdef SIGWINCH
  792. RETSIGTYPE sendwin(int sig) {
  793.     if (connected) sendnaws();
  794. }
  795. #endif
  797. #ifdef SIGINFO
  798. RETSIGTYPE ayt(int sig) {
  799.     if (connected) sendayt();
  800.     else ayt_status();
  801. }
  802. #endif
  804. void sys_telnet_init() {
  805.     Signal(SIGINT, intr);
  806.     Signal(SIGQUIT, intr2);
  807.     Signal(SIGPIPE, deadpeer);
  808. #ifdef SIGWINCH
  809.     Signal(SIGWINCH, sendwin);
  810. #endif
  811. #ifdef SIGTSTP
  812.     Signal(SIGTSTP, susp);
  813. #endif
  814. #ifdef SIGINFO
  815.     Signal(SIGINFO, ayt);
  816. #endif
  818.     setconnmode(0);
  820.     NetNonblockingIO(net, 1);
  822. #ifdef TN3270
  823.     if (noasynchnet == 0) { /* DBX can't handle! */
  824. NetSigIO(net, 1);
  825. NetSetPgrp(net);
  826.     }
  827. #endif
  829. #ifdef SO_OOBINLINE
  830.     if (SetSockOpt(net, SOL_SOCKET, SO_OOBINLINE, 1) == -1) {
  831. perror("SetSockOpt");
  832.     }
  833. #endif
  834. }
  836. /* Process rings -                                                           */
  837. /*                                                                           */
  838. /* This routine tries to fill up/empty our various rings.                    */
  839. /*                                                                           */
  840. /* The parameter specifies whether this is a poll operation, or a            */
  841. /* block-until-something-happens operation.                                  */
  842. /*                                                                           */
  843. /* The return value is 1 if something happened, 0 if not.                    */
  844. int process_rings(int netin, int netout, int netex, int ttyin, int ttyout, int poll) {
  845.     static struct timeval TimeValue = { 0 };
  846.     register int c;
  848.     /* One wants to be a bit careful about setting returnValue to one, since */
  849.     /* a one implies we did some useful work, and therefore probably won't   */
  850.     /* be called to block next time (TN3270 mode only).                      */
  851.     int returnValue = 0;
  853.     if (netout) FD_SET(net,  &obits);
  854.     if (ttyout) FD_SET(tout, &obits);
  855.     if (netin)  FD_SET(net,  &ibits);
  856.     if (ttyin)  FD_SET(tin,  &ibits);
  857.     if (netex)  FD_SET(net,  &xbits);
  859.     if ((c = select(16, &ibits, &obits, &xbits, (poll == 0)?NULL:&TimeValue)) < 0) {
  860. if (c == -1) {
  861.     /* We can get EINTR if we are in line mode, and the user does an */
  862.     /* escape (TSTP), or some other signal generator.                */
  863.     if (errno == EINTR) return 0;
  864. #ifdef TN3270
  865.     /* We can get EBADF if we were in transparent mode, and the      */
  866.     /* transcom process died.                                        */
  867.     if (errno == EBADF) {
  868. /* Zero the bits (even though kernel does it) to make sure   */
  869. /* we are selecting on the right ones.                       */
  870. FD_ZERO(&ibits);
  871. FD_ZERO(&obits);
  872. FD_ZERO(&xbits);
  873. return 0;
  874.     }
  875. #endif
  877.     /* I don't like this, does it ever happen?                       */
  878.     printf("sleep(5) from telnet, after selectrn");
  879.     sleep(5);
  880. }
  882. return 0;
  883.     }
  885.     /* Any urgent data?                                                      */
  886.     if (FD_ISSET(net, &xbits)) {
  887. FD_CLR(net, &xbits);
  888. SYNCHing = 1;
  889. ttyflush(1); /* flush already enqueued data                       */
  890.     }
  892.     /* Something to read from the network...                                 */
  893.     if (FD_ISSET(net, &ibits)) {
  894. int canread;
  896. FD_CLR(net, &ibits);
  897. canread = ring_empty_consecutive(&netiring);
  898. #ifndef SO_OOBINLINE
  899. /* In 4.2 (and some early 4.3) systems, the OOB indication and data  */
  900. /* handling in the kernel is such that if two separate TCP Urgent    */
  901. /* requests come in, one byte of TCP data will be overlaid.  This is */
  902. /* fatal for Telnet, but we try to live with it.                     */
  903. /*                                                                   */
  904. /* In addition, in 4.2 (and...), a special protocol is needed to     */
  905. /* pick up the TCP Urgent data in the correct sequence.              */
  906. /*                                                                   */
  907. /* What we do is: if we think we are in urgent mode, we look to see  */
  908. /* if we are "at the mark".  If we are, we do an OOB receive.  If we */
  909. /* run this twice, we will do the OOB receive twice, but the second  */
  910. /* will fail, since the second time we were "at the mark", but there */
  911. /* wasn't any data there (the kernel doesn't reset "at the mark"     */
  912. /* until we do a normal read).  Once we've read the OOB data, we go  */
  913. /* ahead and do normal reads.                                        */
  914. /*                                                                   */
  915. /* There is also another problem, which is that since the OOB byte   */
  916. /* we read doesn't put us out of OOB state, and since that byte is   */
  917. /* most likely the TELNET DM (data mark), we would stay in the       */
  918. /* TELNET SYNCH (SYNCHing) state.  So, clocks to the rescue.  If     */
  919. /* we've "just" received a DM, then we test for the presence of OOB  */
  920. /* data when the receive OOB fails (and AFTER we did the normal mode */
  921. /* read to clear "at the mark").                                     */
  922. if (SYNCHing) {
  923.     static int bogus_oob = 0, first = 1;
  924.     int atmark;
  926.     ioctl(net, SIOCATMARK, (char *)&atmark);
  927.     if (atmark) {
  928. c = recv(net, netiring.supply, canread, MSG_OOB);
  929. if ((c == -1) && (errno == EINVAL)) {
  930.     c = recv(net, netiring.supply, canread, 0);
  931.     if (clocks.didnetreceive < clocks.gotDM) {
  932. SYNCHing = stilloob(net);
  933.     }
  934. } else if (first && c > 0) {
  935.     /* Bogosity check.  Systems based on 4.2BSD do not       */
  936.     /* return an error if you do a second recv(MSG_OOB).     */
  937.     /* So, we do one.  If it succeeds and returns exactly    */
  938.     /* the same data, then assume that we are running on a   */
  939.     /* broken system and set the bogus_oob flag.  (If the    */
  940.     /* data was different, then we probably got some valid   */
  941.     /* new data, so increment the count...)                  */
  942.     int i = recv(net, netiring.supply+c, canread-c, MSG_OOB);
  944.     if (i == c && memcmp(netiring.supply, netiring.supply + c, i) == 0) {
  945. bogus_oob = 1;
  946. first = 0;
  947.     } else if (i < 0) {
  948. bogus_oob = 0;
  949. first = 0;
  950.     } else {
  951. c += i;
  952.     }
  953. }
  955. if (bogus_oob && c > 0) {
  956.     int i = read(net, netiring.supply+c, canread-c);
  957.     /* Bogosity.  We have to do the read to clear the atmark */
  958.     /* to get out of an infinate loop.                       */
  959.     if (i > 0) c += i;
  960. }
  961.     } else {
  962. c = recv(net, netiring.supply, canread, 0);
  963.     }
  964. } else {
  965.     c = recv(net, netiring.supply, canread, 0);
  966. }
  968. settimer(didnetreceive);
  969. #else
  970. c = recv(net, (char *)netiring.supply, canread, 0);
  971. #endif
  973. if (c < 0 && errno == EWOULDBLOCK) {
  974.     c = 0;
  975. } else if (c <= 0) {
  976.     return -1;
  977. }
  979. if (netdata) {
  980.     Dump('<', netiring.supply, c);
  981. }
  983. if (c) {
  984.     ring_supplied(&netiring, c);
  985. }
  987. returnValue = 1;
  988.     }
  990.     /*
  991.      * Something to read from the tty...
  992.      */
  993.     if (FD_ISSET(tin, &ibits)) {
  994. FD_CLR(tin, &ibits);
  995. c = TerminalRead(ttyiring.supply, ring_empty_consecutive(&ttyiring));
  996. if (c < 0 && errno == EIO) {
  997.     c = 0;
  998. }
  1000. if (c < 0 && errno == EWOULDBLOCK) {
  1001.     c = 0;
  1002. } else {
  1003.     /* EOF detection for line mode!!!! */
  1004.     if ((c == 0) && MODE_LOCAL_CHARS(globalmode) && isatty(tin)) {
  1005. /* must be an EOF... */
  1006. *ttyiring.supply = termEofChar;
  1007. c = 1;
  1008.     }
  1010.     if (c <= 0) {
  1011. return -1;
  1012.     }
  1014.     if (termdata) {
  1015. Dump('<', ttyiring.supply, c);
  1016.     }
  1018.     ring_supplied(&ttyiring, c);
  1019. }
  1021. returnValue = 1; /* did something useful */
  1022.     }
  1024.     if (FD_ISSET(net, &obits)) {
  1025. FD_CLR(net, &obits);
  1026. returnValue |= netflush();
  1027.     }
  1029.     if (FD_ISSET(tout, &obits)) {
  1030. FD_CLR(tout, &obits);
  1031. returnValue |= (ttyflush(SYNCHing|flushout) > 0);
  1032.     }
  1034.     return returnValue;
  1035. }