ip.c File Reference

#include <xinu.h>

Include dependency graph for ip.c:

Go to the source code of this file.

Functions
status	ip_enqueue (struct netpacket *pktptr)
void	ip_hton (struct netpacket *pktptr)
void	ip_in (struct netpacket *pktptr)
void	ip_local (struct netpacket *pktptr)
void	ip_ntoh (struct netpacket *pktptr)
status	ip_out (struct netpacket *pktptr)
status	ip_send (struct netpacket *pktptr)
uint16	ipcksum (struct netpacket *pkt)
process	ipout (void)

Variables
struct iqentry	ipoqueue
	ネットワーク送信キュー More...

Function Documentation

ip_enqueue()

status ip_enqueue

(

struct netpacket *

pktptr

)

Definition at line 439 of file ip.c.

References disable(), freebuf(), IP_OQSIZ, ipoqueue, iqentry::iqbuf, iqentry::iqsem, iqentry::iqtail, kprintf(), OK, restore(), semcount(), signal(), and SYSERR.

Referenced by icmp_in().

{
    intmask mask;           /* Saved interrupt mask     */
    struct  iqentry *iptr;      /* Ptr. to network output queue */

    /* Ensure only one process accesses output queue at a time */

    mask = disable();

    /* Enqueue packet on network output queue */

    iptr = &ipoqueue;
    if (semcount(iptr->iqsem) >= IP_OQSIZ) {
        kprintf("ipout: output queue overflow\n");
        freebuf((char *)pktptr);
        restore(mask);
        return SYSERR;
    }
    iptr->iqbuf[iptr->iqtail++] = pktptr;
    if (iptr->iqtail >= IP_OQSIZ) {
        iptr->iqtail = 0;
    }
    signal(iptr->iqsem);
    restore(mask);
    return OK;  
}

Here is the call graph for this function:

Here is the caller graph for this function:

ip_hton()

void ip_hton

(

struct netpacket *

pktptr

)

Definition at line 338 of file ip.c.

References htonl, htons, netpacket::net_ipdst, netpacket::net_ipfrag, netpacket::net_ipid, netpacket::net_iplen, and netpacket::net_ipsrc.

Referenced by ip_out().

{
    pktptr->net_iplen = htons(pktptr->net_iplen);
    pktptr->net_ipid = htons(pktptr->net_ipid);
    pktptr->net_ipfrag = htons(pktptr->net_ipfrag);
    pktptr->net_ipsrc = htonl(pktptr->net_ipsrc);
    pktptr->net_ipdst = htonl(pktptr->net_ipdst);
}

Here is the caller graph for this function:

ip_in()

void ip_in

(

struct netpacket *

pktptr

)

Definition at line 13 of file ip.c.

References freebuf(), icmp_cksum(), icmp_ntoh(), IP_BCAST, IP_HDR_LEN, IP_ICMP, ip_local(), ip_ntoh(), IP_UDP, network::ipbcast, ipcksum(), network::ipucast, network::ipvalid, kprintf(), netpacket::net_ictype, netpacket::net_ipdst, netpacket::net_iplen, netpacket::net_ipproto, netpacket::net_ipvh, NetData, and udp_ntoh().

Referenced by netin().

{
    int32   icmplen;        /* Length of ICMP message   */

    /* Verify checksum */

    if (ipcksum(pktptr) != 0) {
        kprintf("IP header checksum failed\n\r");
        freebuf((char *)pktptr);
        return;
    }

    /* Convert IP header fields to host order */

    ip_ntoh(pktptr);

    /* Ensure version and length are valid */

    if (pktptr->net_ipvh != 0x45) {
        kprintf("IP version failed\n\r");
        freebuf((char *)pktptr);
        return;
    }

    /* Verify encapsulated prototcol checksums and then convert */
    /*  the encapsulated headers to host byte order     */

    switch (pktptr->net_ipproto) {

        case IP_UDP:
        /* Skipping UDP checksum for now */
        udp_ntoh(pktptr);
        break;

        case IP_ICMP:
        icmplen = pktptr->net_iplen - IP_HDR_LEN;
        if (icmp_cksum((char *)&pktptr->net_ictype,icmplen) != 0){
            freebuf((char *)pktptr);
            return;
        }
        icmp_ntoh(pktptr);
        break;

        default:
        break;
    }

    /* Deliver 255.255.255.255 to local stack */

    if (pktptr->net_ipdst == IP_BCAST) {
        ip_local(pktptr);
        return;
    }

    /* If we do not yet have a valid address, accept UDP packets    */
    /*  (to get DHCP replies) and drop others           */

    if (!NetData.ipvalid) {
        if (pktptr->net_ipproto == IP_UDP) {
            ip_local(pktptr);
            return;
        } else {
            freebuf((char *)pktptr);
            return;
        }
    }

    /* If packet is destined for us, accept it; otherwise, drop it  */

    if ( (pktptr->net_ipdst == NetData.ipucast) ||
         (pktptr->net_ipdst == NetData.ipbcast) ||
         (pktptr->net_ipdst == IP_BCAST)  ) {
        ip_local(pktptr);
        return;
    } else {

        /* Drop the packet */
        freebuf((char *)pktptr);
        return;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ip_local()

void ip_local

(

struct netpacket *

pktptr

)

Definition at line 186 of file ip.c.

References freebuf(), icmp_in(), IP_ICMP, IP_UDP, netpacket::net_ipproto, and udp_in().

Referenced by ip_in(), ip_send(), and ipout().

{
    /* Use datagram contents to determine how to process */

    switch (pktptr->net_ipproto) {

        case IP_UDP:
        udp_in(pktptr);
        return;

        case IP_ICMP:
        icmp_in(pktptr);
        return;

        default:
        freebuf((char *)pktptr);
        return;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ip_ntoh()

void ip_ntoh

(

struct netpacket *

pktptr

)

Definition at line 323 of file ip.c.

References netpacket::net_ipdst, netpacket::net_ipfrag, netpacket::net_ipid, netpacket::net_iplen, netpacket::net_ipsrc, ntohl, and ntohs.

Referenced by ip_in().

{
    pktptr->net_iplen = ntohs(pktptr->net_iplen);
    pktptr->net_ipid = ntohs(pktptr->net_ipid);
    pktptr->net_ipfrag = ntohs(pktptr->net_ipfrag);
    pktptr->net_ipsrc = ntohl(pktptr->net_ipsrc);
    pktptr->net_ipdst = ntohl(pktptr->net_ipdst);
}

Here is the caller graph for this function:

ip_out()

status ip_out

(

struct netpacket *

pktptr

)

Definition at line 213 of file ip.c.

References ETH_HDR_LEN, eth_hton(), ETHER0, freebuf(), htons, icmp_cksum(), icmp_hton(), IP_HDR_LEN, ip_hton(), IP_ICMP, IP_UDP, ipcksum(), netpacket::net_iccksum, netpacket::net_ictype, netpacket::net_ipcksum, netpacket::net_iplen, netpacket::net_ipproto, netpacket::net_udpcksum, OK, SYSERR, udp_hton(), and write().

Referenced by ip_send(), and ipout().

{
    uint16  cksum;          /* Checksum in host byte order  */
    int32   len;            /* Length of ICMP message   */  
    int32   pktlen;         /* Length of entire packet  */
    int32   retval;         /* Value returned by write  */

    /* Compute total packet length */

    pktlen = pktptr->net_iplen + ETH_HDR_LEN;

    /* Convert encapsulated protocol to network byte order */

    switch (pktptr->net_ipproto) {

        case IP_UDP:

            pktptr->net_udpcksum = 0;
            udp_hton(pktptr);

            /* ...skipping UDP checksum computation */

            break;

        case IP_ICMP:
            icmp_hton(pktptr);

            /* Compute ICMP checksum */

            pktptr->net_iccksum = 0;
            len = pktptr->net_iplen-IP_HDR_LEN;
            cksum = icmp_cksum((char *)&pktptr->net_ictype,
                                len);
            pktptr->net_iccksum = 0xffff & htons(cksum);
            break;

        default:
            break;
    }

    /* Convert IP fields to network byte order */

    ip_hton(pktptr);

    /* Compute IP header checksum */

    pktptr->net_ipcksum = 0;
    cksum = ipcksum(pktptr);
    pktptr->net_ipcksum = 0xffff & htons(cksum);

    /* Convert Ethernet fields to network byte order */

    eth_hton(pktptr);

    /* Send packet over the Ethernet */

    retval = write(ETHER0, (char*)pktptr, pktlen);
    freebuf((char *)pktptr);

    if (retval == SYSERR) {
        return SYSERR;
    } else {
        return OK;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ip_send()

status ip_send

(

struct netpacket *

pktptr

)

Definition at line 103 of file ip.c.

References arp_resolve(), disable(), ETH_ADDR_LEN, network::ethbcast, freebuf(), IP_BCAST, ip_local(), ip_out(), network::ipbcast, network::ipmask, network::ipprefix, network::iprouter, network::ipucast, memcpy(), netpacket::net_ethdst, netpacket::net_ipdst, NetData, OK, restore(), and SYSERR.

Referenced by icmp_send(), udp_send(), and udp_sendto().

{
    intmask mask;           /* Saved interrupt mask     */
    uint32  dest;           /* Destination of the datagram  */
    int32   retval;         /* Return value from functions  */
    uint32  nxthop;         /* Next-hop address     */

    mask = disable();

    /* Pick up the IP destination address from the packet */

    dest = pktptr->net_ipdst;

    /* Loop back to local stack if destination 127.0.0.0/8 */

    if ((dest&0xff000000) == 0x7f000000) {
        ip_local(pktptr);
        restore(mask);
        return OK;
    }

    /* Loop back if the destination matches our IP unicast address  */

    if (dest == NetData.ipucast) {
        ip_local(pktptr);
        restore(mask);
        return OK;
    }

    /* Broadcast if destination is 255.255.255.255 */

    if ( (dest == IP_BCAST) ||
         (dest == NetData.ipbcast) ) {
        memcpy(pktptr->net_ethdst, NetData.ethbcast,
                            ETH_ADDR_LEN);
        retval = ip_out(pktptr);
        restore(mask);
        return retval;
    }

    /* If destination is on the local network, next hop is the  */
    /*  destination; otherwise, next hop is default router  */


    if ( (dest & NetData.ipmask) == NetData.ipprefix) {

        /* Next hop is the destination itself */
        nxthop = dest;

    } else {

        /* Next hop is default router on the network */
        nxthop = NetData.iprouter;

    }

    if (nxthop == 0) {  /* Dest. invalid or no default route    */
        freebuf((char *)pktptr);
        return SYSERR;
    }

    /* Resolve the next-hop address to get a MAC address */

    retval = arp_resolve(nxthop, pktptr->net_ethdst);
    if (retval != OK) {
        freebuf((char *)pktptr);
        return SYSERR;
    }

    /* Send the packet */

    retval = ip_out(pktptr);
    restore(mask);
    return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ipcksum()

uint16 ipcksum

(

struct netpacket *

pkt

)

Definition at line 286 of file ip.c.

References htons, and netpacket::net_ipvh.

Referenced by ip_in(), ip_out(), pdump(), and pdumph().

{
    uint16  *hptr;          /* Ptr to 16-bit header values  */
    int32   i;          /* Counts 16-bit values in hdr  */
    uint16  word;           /* One 16-bit word      */
    uint32  cksum;          /* Computed value of checksum   */

    hptr= (uint16 *) &pkt->net_ipvh;

    /* Sum 16-bit words in the packet */

    cksum = 0;
    for (i=0; i<10; i++) {
        word = *hptr++;
        cksum += (uint32) htons(word);
    }

    /* Add in carry, and take the ones-complement */

    cksum += (cksum >> 16);
    cksum = 0xffff & ~cksum;

    /* Use all-1s for zero */

    if (cksum == 0xffff) {
        cksum = 0;
    }
    return (uint16) (0xffff & cksum);
}

Here is the caller graph for this function:

ipout()

process ipout

(

void

)

Definition at line 356 of file ip.c.

References arp_resolve(), ETH_ADDR_LEN, network::ethucast, freebuf(), IP_BCAST, ip_local(), IP_OQSIZ, ip_out(), network::ipbcast, network::ipmask, ipoqueue, network::ipprefix, network::iprouter, network::ipucast, iqentry::iqbuf, iqentry::iqhead, iqentry::iqsem, kprintf(), memcpy(), netpacket::net_ethdst, netpacket::net_ethsrc, netpacket::net_ipdst, NetData, OK, and wait().

Referenced by net_init().

{
    struct  netpacket *pktptr;  /* Pointer to next the packet   */
    struct  iqentry   *ipqptr;  /* Pointer to IP output queue   */
    uint32  destip;         /* Destination IP address   */
    uint32  nxthop;         /* Next hop IP address      */
    int32   retval;         /* Value returned by functions  */

    ipqptr = &ipoqueue;

    while(1) {

        /* Obtain next packet from the IP output queue */

        wait(ipqptr->iqsem);
        pktptr = ipqptr->iqbuf[ipqptr->iqhead++];
        if (ipqptr->iqhead >= IP_OQSIZ) {
            ipqptr->iqhead= 0;
        }

        /* Fill in the MAC source address */

        memcpy(pktptr->net_ethsrc, NetData.ethucast, ETH_ADDR_LEN);

        /* Extract destination address from packet */

        destip = pktptr->net_ipdst;


        /* Sanity check: packets sent to ipout should *not* */
        /*  contain a broadcast address.            */

        if ((destip == IP_BCAST)||(destip == NetData.ipbcast)) {
            kprintf("ipout: encountered a broadcast\n");
            freebuf((char *)pktptr);
            continue;
        }

        /* Check whether destination is the local computer */

        if (destip == NetData.ipucast) {
            ip_local(pktptr);
            continue;
        }

        /* Check whether destination is on the local net */

        if ( (destip & NetData.ipmask) == NetData.ipprefix) {

            /* Next hop is the destination itself */

            nxthop = destip;
        } else {

            /* Next hop is default router on the network */

            nxthop = NetData.iprouter;
        }

        if (nxthop == 0) {  /* Dest. invalid or no default route*/
            freebuf((char *)pktptr);
            continue;
        }

        /* Use ARP to resolve next-hop address */

        retval = arp_resolve(nxthop, pktptr->net_ethdst);
        if (retval != OK) {
            freebuf((char *)pktptr);
            continue;
        }

        /* Use ipout to Convert byte order and send */

        ip_out(pktptr);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

ipoqueue

struct iqentry ipoqueue

ネットワーク送信キュー

Definition at line 6 of file ip.c.

Referenced by ip_enqueue(), ipout(), and net_init().