Return to dgread.c CVS log

Up to [XINU] / xinu / sys

Annotation of xinu/sys/dgread.c, revision 1.1

1.1     ! root        1: /* dgread.c - dgread */
        !             2: 
        !             3: #include <conf.h>
        !             4: #include <kernel.h>
        !             5: #include <proc.h>
        !             6: #include <network.h>
        !             7: 
        !             8: /*------------------------------------------------------------------------
        !             9:  *  dgread  -  read one datagram from a datagram protocol pseudo-device
        !            10:  *------------------------------------------------------------------------
        !            11:  */
        !            12: dgread(devptr, buff, len)
        !            13: struct devsw   *devptr;
        !            14: struct xgram   *buff;
        !            15: int    len;
        !            16: {
        !            17:        struct  dgblk   *dgptr;
        !            18:        struct  epacket *packet;
        !            19:        struct  udp     *udpptr;
        !            20:        struct  ip      *ipptr;
        !            21:        struct  netq    *nqptr;
        !            22:        int     datalen;
        !            23:        PStype  ps;
        !            24: 
        !            25:        disable(ps);
        !            26:        dgptr = (struct dgblk *)devptr->dvioblk;
        !            27:        if (dgptr->dg_mode & DG_TMODE) {
        !            28:                nqptr = &Net.netqs[dgptr->dg_netq];
        !            29:                if ( !isbadpid(nqptr->pid) ) {
        !            30:                        restore(ps);
        !            31:                        return(SYSERR);
        !            32:                }
        !            33:                if (pcount(dgptr->dg_xport) <= 0) {
        !            34:                        nqptr->pid = getpid();
        !            35:                        if (recvtim(DG_TIME) == TIMEOUT) {
        !            36:                                nqptr->pid = BADPID;
        !            37:                                restore(ps);
        !            38:                                return(TIMEOUT);
        !            39:                        }
        !            40:                }
        !            41:        }
        !            42:        packet = (struct epacket *) preceive(dgptr->dg_xport);
        !            43: 
        !            44:        /* copy data into user's buffer & set length */
        !            45: 
        !            46:        ipptr = (struct ip *) packet->ep_data;
        !            47:        udpptr = (struct udp *)ipptr->i_data;
        !            48:        datalen = net2hs(udpptr->u_udplen) - UHLEN;
        !            49:        if (dgptr->dg_mode & DG_NMODE) {
        !            50:                if ( (datalen+XGHLEN) > len) {
        !            51:                        freebuf(packet);
        !            52:                        restore(ps);
        !            53:                        return(SYSERR);
        !            54:                }
        !            55:                blkcopy(buff->xg_faddr, ipptr->i_src, IPLEN);
        !            56:                buff->xg_fport = net2hs(udpptr->u_sport);
        !            57:                buff->xg_lport = dgptr->dg_lport;
        !            58:                blkcopy(buff->xg_data, udpptr->u_data, datalen);
        !            59:        } else {
        !            60:                if (datalen > len)
        !            61:                        datalen = len;
        !            62:                blkcopy(buff, udpptr->u_data, datalen);
        !            63:        }
        !            64:        freebuf(packet);
        !            65:        restore(ps);
        !            66:        return(datalen);
        !            67: }

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