Return to sppclose.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / xns / xnslib

Annotation of 43BSD/contrib/xns/xnslib/sppclose.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * Routines for closing an SPP connection
                      3:  */
                      4: 
                      5: /*
                      6:  $Log: sppclose.c,v $
                      7:  * Revision 2.0  85/11/21  07:22:21  jqj
                      8:  * 4.3BSD standard release
                      9:  * 
                     10:  * Revision 1.3  85/03/11  16:37:50  jqj
                     11:  * *** empty log message ***
                     12:  * 
                     13:  * Revision 1.3  85/03/11  16:37:50  jqj
                     14:  * Public alpha-test version, released 11 March 1985
                     15:  * 
                     16:  * Revision 1.2  85/01/27  07:37:52  jqj
                     17:  * finished but undebugged version
                     18:  * 
                     19:  */
                     20: 
                     21: #ifndef lint
                     22: static char rcsid[] = "$Header: sppclose.c,v 2.0 85/11/21 07:22:21 jqj Exp $";
                     23: #endif
                     24: 
                     25: /* #include <stdio.h> */
                     26: #include <sys/types.h>         /* for ns.h */
                     27: #include <sys/socket.h>
                     28: #include <sys/time.h>
                     29: #include <netns/ns.h>          /* for misc. constants */
                     30: #include <netns/sp.h>          /* for spphdr */
                     31: #include "courier.h"
                     32: 
                     33: #ifndef SPPMAXDATA
                     34: #define SPPMAXDATA 534
                     35: #endif
                     36: 
                     37: #ifndef TRUE
                     38: #define TRUE (1)
                     39: #define FALSE (0)
                     40: #define NULL ((char*)0)
                     41: #endif
                     42: 
                     43: int
                     44: sppclose(s)
                     45: /* try to close an SPP connection by sending an END packet. */
                     46: /* return TRUE on normal close, FALSE on abnormal close */
                     47:        int s;
                     48: {
                     49:        int fdmask;
                     50:        static struct timeval timeout = {15,0};
                     51:        struct {
                     52:                struct sphdr hdr;
                     53:                char data[SPPMAXDATA];
                     54:        } packbuf;
                     55: 
                     56:                /* streamtype=254, EOM=FALSE, Attn=FALSE */
                     57:        packbuf.hdr.sp_dt = SPPSST_END;
                     58:        packbuf.hdr.sp_cc = 0;
                     59:        fdmask = 1<<s;
                     60:        if (write(s, &packbuf, sizeof(packbuf.hdr)) >= 0
                     61:            && select(s+1,&fdmask,(int*)NULL,(int*)NULL,&timeout) > 0
                     62:            && read(s,(char*)&packbuf,sizeof(packbuf)) > 0) {
                     63:                if (packbuf.hdr.sp_dt == SPPSST_ENDREPLY) {
                     64:                        /* normal close */
                     65:                        /* SetSPPoptions(s, SPPSST_ENDREPLY, 0, 0);
                     66:                                /* streamtype=255, EOM=FALSE, Attn=FALSE */
                     67:                        packbuf.hdr.sp_dt = SPPSST_ENDREPLY;
                     68:                        packbuf.hdr.sp_cc = 0;
                     69:                        if (write(s, &packbuf, sizeof(packbuf.hdr)) >= 0
                     70:                            && shutdown(s,0) >= 0) {
                     71:                                /* don't read any more, but */
                     72:                                /*  try to get ENDREPLY out */
                     73:                                (void) close(s);
                     74:                                return(TRUE);
                     75:                        }
                     76:                        /* fall out of if to abnormal close */
                     77:                }
                     78:                else if (packbuf.hdr.sp_dt == SPPSST_END) {
                     79:                        /* simultaneous close */
                     80:                        return(sppclosereply(s));
                     81:                }
                     82:                /* else must have been a data packet -- abnormal close */
                     83:                /* fall through */
                     84:        }
                     85:        /* timer expired, data packet arrived, or write failed */
                     86:        (void) shutdown(s,2);           /* throw away all data */
                     87:        (void) close(s);
                     88:        return(FALSE);
                     89: }
                     90: 
                     91: int
                     92: sppclosereply(s)
                     93: /* handle receipt of a packet of type END, by closing down the SPP
                     94:  * connection.  Returns TRUE on normal close, FALSE otherwise.
                     95:  */
                     96:        int s;          /* spp socket */
                     97: {
                     98:        int fdmask;
                     99:        static struct timeval timeout = {10,0};
                    100:        struct {
                    101:                struct sphdr hdr;
                    102:                char data[SPPMAXDATA];
                    103:        } packbuf;
                    104: 
                    105:        fdmask = 1<<s;
                    106:        /* SetSPPoptions(s, SPPSST_ENDREPLY, 0, 0);
                    107:                /* streamtype=255, EOM=FALSE, Attn=FALSE */
                    108:        packbuf.hdr.sp_dt = SPPSST_ENDREPLY;
                    109:        packbuf.hdr.sp_cc = 0;
                    110:        if (write(s, &packbuf, sizeof(packbuf.hdr))
                    111:            && select(s+1, &fdmask, (int*)NULL, (int*)NULL, &timeout) > 0
                    112:            && read(s, (char*)&packbuf, sizeof(packbuf)) > 0
                    113:            && shutdown(s,2) == 0) {
                    114:                close(s);
                    115:                return(packbuf.hdr.sp_dt == SPPSST_ENDREPLY);
                    116:        }
                    117:        /* write failed, timeout expired, or error occured */
                    118:        (void) shutdown(s,2);   /* throw away any data */
                    119:        (void) close(s);
                    120:        return(FALSE);
                    121: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.