home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 1: Amiga / FrozenFish-Apr94.iso / bbs / alib / d2xx / d294 / dnet.lha / DNet / unix / dnet / files.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-12-11  |  3.4 KB  |  158 lines
  1.  
  2. /*
  3.  * FILES.C
  4.  *
  5.  *    DNET (c)Copyright 1988, Matthew Dillon, All Rights Reserved
  6.  *
  7.  *    handles actions on a per file descriptor basis, including accepting
  8.  *    new connections, closing old connections, and transfering data
  9.  *    between connections.
  10.  */
  11.  
  12. #include "dnet.h"
  13.  
  14. extern void do_localopen(), do_connect(), do_open1(), do_openwait(), do_open();
  15.  
  16. /*
  17.  *  new connection over master port... open request.  read two byte port
  18.  *  number, allocate a channel, and send off to the remote
  19.  */
  20.  
  21. void
  22. do_localopen(n, fd)
  23. {
  24.     struct sockaddr sa;
  25.     int addrlen = sizeof(sa);
  26.     int s;
  27.     uword chan;
  28.  
  29.     if (DDebug)
  30.     fprintf(stderr, "DO_LOCALOPEN %ld %ld\n", n, fd);
  31.     while ((s = accept(fd, &sa, &addrlen)) >= 0) {
  32.     chan = alloc_channel();
  33.     fcntl(s, F_SETFL, FNDELAY);
  34.     if (DDebug)
  35.         fprintf(stderr, " ACCEPT: %ld on channel %ld ", s, chan);
  36.     if (chan == 0xFFFF) {
  37.         ubyte error = 1;
  38.         gwrite(s, &error, 1);
  39.         close(s);
  40.         if (DDebug)
  41.             fprintf(stderr, "(no channels)\n");
  42.         continue;
  43.     } 
  44.     Fdstate[s] = do_open1;
  45.     FdChan[s] = chan;
  46.     FD_SET(s, &Fdread);
  47.     FD_SET(s, &Fdexcept);
  48.     Chan[chan].fd = s;
  49.     Chan[chan].state = CHAN_LOPEN;
  50.     if (DDebug)
  51.         fprintf(stderr, "(State = CHAN_LOPEN)\n");
  52.     }
  53. }
  54.  
  55. void
  56. do_open1(n_notused, fd)
  57. {
  58.     uword port;
  59.     char  trxpri[2];
  60.     uword chan = FdChan[fd];
  61.     COPEN co;
  62.     int n;
  63.  
  64.     if (DDebug)
  65.     fprintf(stderr, "DO_OPEN %ld %ld on channel %ld  ", n, fd, chan);
  66.     for (;;) {
  67.         n = read(fd, &port, 2);
  68.     if (n < 0) {
  69.         if (errno == EINTR)
  70.         continue;
  71.         if (errno == EWOULDBLOCK)
  72.         return;
  73.     }
  74.     read(fd, trxpri, 2);
  75.     if (n != 2)
  76.         dneterror("do_open1: unable to read 2 bytes");
  77.     break;
  78.     }
  79.     if (DDebug)
  80.     fprintf(stderr, "Port %ld\n", port);
  81.     co.chanh = chan >> 8;
  82.     co.chanl = chan;
  83.     co.porth = port >> 8;
  84.     co.portl = port;
  85.     co.error = 0;
  86.     co.pri   = trxpri[1];
  87.     Chan[chan].port = port;
  88.     Chan[chan].pri = 126;
  89.     WriteStream(SCMD_OPEN, &co, sizeof(co), chan);
  90.     Chan[chan].pri = trxpri[0];
  91.     Fdstate[fd] = do_openwait;
  92.     if (DDebug)
  93.         fprintf(stderr, " Newstate = openwait\n");
  94. }
  95.  
  96. void
  97. do_openwait(n, fd)
  98. {
  99.     ubyte buf[32];
  100.     if (DDebug)
  101.     fprintf(stderr, "************ ERROR DO_OPENWAIT %ld %ld\n", n, fd);
  102.     n = read(fd, buf, 32);
  103.     if (DDebug) {
  104.     fprintf(stderr, "    OPENWAIT, READ %ld bytes\n", n);
  105.         if (n < 0)
  106.         perror("openwait:read");
  107.     }
  108. }
  109.  
  110. void
  111. do_open(nn, fd)
  112. {
  113.     extern void nop();
  114.     char buf[256];
  115.     uword chan = FdChan[fd];
  116.     int n;
  117.  
  118.     n = read(fd, buf, sizeof(buf));
  119.     if (DDebug) {
  120.     fprintf(stderr, "DO_OPEN %ld %ld, RECEIVE DATA on chan %ld (%ld by)\n",
  121.         nn, fd, chan, n);
  122.     fprintf(stderr, " fd, chanfd %ld %ld\n", fd, Chan[chan].fd);
  123.     if (n < 0)
  124.         perror("open:read");
  125.     }
  126.     if (n == 0 || nn == 2) {    /* application closed / exception cond */
  127.     CCLOSE cc;
  128.  
  129.     if (DDebug)
  130.         fprintf(stderr, " DO_OPEN: REMOTE EOF, channel %d\n", chan);
  131.  
  132.     cc.chanh = chan >> 8;
  133.     cc.chanl = chan;
  134.     WriteStream(SCMD_CLOSE, &cc, sizeof(CCLOSE), chan);
  135.     Chan[chan].state = CHAN_CLOSE;
  136.     Chan[chan].flags |= CHANF_LCLOSE;
  137.     if (Chan[chan].flags & CHANF_RCLOSE) {
  138.         ;
  139.         /* should never happen
  140.         int fd = Chan[chan].fd;
  141.         Chan[chan].state = CHAN_FREE;
  142.         Chan[chan].fd = -1;
  143.         Fdstate[fd] = nop;
  144.         FD_CLR(fd, &Fdread);
  145.         FD_CLR(fd, &Fdexcept);
  146.         close(fd);
  147.         */
  148.     } else {
  149.         FD_CLR(fd, &Fdread);
  150.         FD_CLR(fd, &Fdexcept);
  151.     }
  152.     }
  153.     if (n > 0) {
  154.     WriteStream(SCMD_DATA, buf, n, chan);
  155.     }
  156. }
  157.  
  158.