Return to dgread.c CVS log

Up to [XINU] / xinu / sys

Annotation of xinu/sys/dgread.c, revision 1.1.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.