home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / inetutils-1.2-src.tgz / tar.out / fsf / inetutils / telnet / network.c < prev    next >
C/C++ Source or Header  |  1996-09-28  |  5KB  |  182 lines
  1. /*
  2.  * Copyright (c) 1988, 1993
  3.  *    The Regents of the University of California.  All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  * 1. Redistributions of source code must retain the above copyright
  9.  *    notice, this list of conditions and the following disclaimer.
  10.  * 2. Redistributions in binary form must reproduce the above copyright
  11.  *    notice, this list of conditions and the following disclaimer in the
  12.  *    documentation and/or other materials provided with the distribution.
  13.  * 3. All advertising materials mentioning features or use of this software
  14.  *    must display the following acknowledgement:
  15.  *    This product includes software developed by the University of
  16.  *    California, Berkeley and its contributors.
  17.  * 4. Neither the name of the University nor the names of its contributors
  18.  *    may be used to endorse or promote products derived from this software
  19.  *    without specific prior written permission.
  20.  *
  21.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31.  * SUCH DAMAGE.
  32.  */
  33.  
  34. #ifndef lint
  35. static char sccsid[] = "@(#)network.c    8.2 (Berkeley) 12/15/93";
  36. #endif /* not lint */
  37.  
  38. #ifdef HAVE_CONFIG_H
  39. #include <config.h>
  40. #endif
  41.  
  42. #include <sys/types.h>
  43. #include <sys/socket.h>
  44. #include <sys/time.h>
  45.  
  46. #include <errno.h>
  47.  
  48. #include <arpa/telnet.h>
  49.  
  50. #include "ring.h"
  51.  
  52. #include "defines.h"
  53. #include "externs.h"
  54. #include "fdset.h"
  55.  
  56. Ring        netoring, netiring;
  57. unsigned char    netobuf[2*BUFSIZ], netibuf[BUFSIZ];
  58.  
  59. /*
  60.  * Initialize internal network data structures.
  61.  */
  62.  
  63.     void
  64. init_network()
  65. {
  66.     if (ring_init(&netoring, netobuf, sizeof netobuf) != 1) {
  67.     exit(1);
  68.     }
  69.     if (ring_init(&netiring, netibuf, sizeof netibuf) != 1) {
  70.     exit(1);
  71.     }
  72.     NetTrace = stdout;
  73. }
  74.  
  75.  
  76. /*
  77.  * Check to see if any out-of-band data exists on a socket (for
  78.  * Telnet "synch" processing).
  79.  */
  80.  
  81.     int
  82. stilloob()
  83. {
  84.     static struct timeval timeout = { 0 };
  85.     fd_set    excepts;
  86.     int value;
  87.  
  88.     do {
  89.     FD_ZERO(&excepts);
  90.     FD_SET(net, &excepts);
  91.     value = select(net+1, (fd_set *)0, (fd_set *)0, &excepts, &timeout);
  92.     } while ((value == -1) && (errno == EINTR));
  93.  
  94.     if (value < 0) {
  95.     perror("select");
  96.     (void) quit();
  97.     /* NOTREACHED */
  98.     }
  99.     if (FD_ISSET(net, &excepts)) {
  100.     return 1;
  101.     } else {
  102.     return 0;
  103.     }
  104. }
  105.  
  106.  
  107. /*
  108.  *  setneturg()
  109.  *
  110.  *    Sets "neturg" to the current location.
  111.  */
  112.  
  113.     void
  114. setneturg()
  115. {
  116.     ring_mark(&netoring);
  117. }
  118.  
  119.  
  120. /*
  121.  *  netflush
  122.  *        Send as much data as possible to the network,
  123.  *    handling requests for urgent data.
  124.  *
  125.  *        The return value indicates whether we did any
  126.  *    useful work.
  127.  */
  128.  
  129.  
  130.     int
  131. netflush()
  132. {
  133.     register int n, n1;
  134.  
  135. #ifdef    ENCRYPTION
  136.     if (encrypt_output)
  137.     ring_encrypt(&netoring, encrypt_output);
  138. #endif    /* ENCRYPTION */
  139.     if ((n1 = n = ring_full_consecutive(&netoring)) > 0) {
  140.     if (!ring_at_mark(&netoring)) {
  141.         n = send(net, (char *)netoring.consume, n, 0); /* normal write */
  142.     } else {
  143.         /*
  144.          * In 4.2 (and 4.3) systems, there is some question about
  145.          * what byte in a sendOOB operation is the "OOB" data.
  146.          * To make ourselves compatible, we only send ONE byte
  147.          * out of band, the one WE THINK should be OOB (though
  148.          * we really have more the TCP philosophy of urgent data
  149.          * rather than the Unix philosophy of OOB data).
  150.          */
  151.         n = send(net, (char *)netoring.consume, 1, MSG_OOB);/* URGENT data */
  152.     }
  153.     }
  154.     if (n < 0) {
  155.     if (errno != ENOBUFS && errno != EWOULDBLOCK) {
  156.         setcommandmode();
  157.         perror(hostname);
  158.         (void)NetClose(net);
  159.         ring_clear_mark(&netoring);
  160.         longjmp(peerdied, -1);
  161.         /*NOTREACHED*/
  162.     }
  163.     n = 0;
  164.     }
  165.     if (netdata && n) {
  166.     Dump('>', netoring.consume, n);
  167.     }
  168.     if (n) {
  169.     ring_consumed(&netoring, n);
  170.     /*
  171.      * If we sent all, and more to send, then recurse to pick
  172.      * up the other half.
  173.      */
  174.     if ((n1 == n) && ring_full_consecutive(&netoring)) {
  175.         (void) netflush();
  176.     }
  177.     return 1;
  178.     } else {
  179.     return 0;
  180.     }
  181. }
  182.