As its name suggests, ip_read.c contains code that handles the ip layer of a read request. For example, when an packet destined for a udp file descriptor arrives at an ethernet port, the path of the code is the following:

eth_arrive() 

  ip_eth_arrived() 



    if (unicast packet)

      ip_arrived()

    else if (ethernet broadcast packet)

      ip_arrived_broadcast()



      if (packet must be input routed)

        hand off packet to destination ip port

      else {

        ip_port_arrive() 

          packet2user()

            udp_ip_arrived() 

      }

ip_read.c contains ip_arrived(), ip_arrived_broadcast(), ip_port_arrive(), and packet2user().

Additionally, ip_read.c contains functions that reassemble fragmented packets.

ip_read()

If there are unexpired packets in the ip file descriptor fd's read queue, ip_read(fd, count) passes count (ip_read()'s second parameter) bytes off to the next-higher layer by calling packet2user(). If the packets in the file descriptor's read queue have expired, ip_read() discards the packets.

ip_read() is (indirectly) called by sr_rwio() when a process reads an ip device file (e.g., /dev/ip).

In the udp code, ip_read() is called by read_ip_packets() during the initialization of the udp code. Normally, ip_read() is not called by the udp code after the initialization.

Before an ip file descriptor may be used (for example, before the ip file descriptor may be read from), the file descriptor must be configured. Once configured, the IFF_OPTSET flag in the if_flags field of the ip file descriptor is set.

The if_srfd field points to the file descriptor of the higher layer. For example, if the udp code acquired the ip file descriptor, if_srfd points to a udp file descriptor.

If the udp code opened the ip file descriptor, it expected that the ip file descriptor was configured and the network service will terminate

The IFF_READ_IP flag indicates that a read operation is in progress.

When a udp port is being initialized, the udp port opens up an ip file descriptor. Immediately after initialization, the udp code calls ip_read(), which sets the IFF_READ_IP flag. This flag will never be cleared while the ip file descriptor is open. What this means is that any packet destined for a udp file descriptor can always be immediately handed off to the udp code.

If data arrived from the eth/psip port destined for the ip file descriptor, the if_rdbuf_head queue for the ip file descriptor will be non-null.

Verify that the timer for the ip file descriptor hasn't expired. This timer is set if the ip file descriptor receives a packet while it is not being read (see line 42375).


get_time()

get_time() returns the number of clock ticks since reboot.

Several of the clients (eth, arp, ip, tcp, and udp) use get_time() to determine an appropriate timeout value for a given operation. For example, the arp code calls get_time() to determine an appropriate amount of time to wait for a response from an arp request before giving up.

packet2user() / ip

packet2user() attempts to pass a packet off to a higher layer (e.g., udp). If the ip file descriptor is not currently being read (i.e., the IFF_READ_IP flag in the if_flags field of the ip file descriptor is not set), packet2user() puts the packet at the end of its read queue and returns. Note that if the udp code opened the ip file descriptor, however, the udp code set the IFF_READ_IP flag during its initialization and that this flag remains set until the ip file descriptor is closed.

The packets in the read queue of the ip file descriptor have expired. Discard them.

bf_afree()

After a chain of accessors is no longer needed, the chain (and not simply the single accessor passed as the parameter) can be freed by calling bf_free(). However, if either acc_linkC or buf_linkC of one of the accessors in the linked list is not equal to one (1), the entire chain will not be freed. For example, if buf_afree(acc1) is called for the following chain:



Then the resulting chain will be:



bf_afree() returns acc1 (accessors[63]) to acc_freelist (recall that acc_freelist is the linked list of acc_t's without an associated buffer). However, buffers512[127] cannot be freed because acc2 (accessors[64]) still references it.

bf_afree() is called after an accessor's associated data is no longer needed (for example, after a packet has been sent off by the ethernet driver).

reassemble()

reassemble() reassembles a packet from its fragments. reassemble() either adds a fragment to ip_ass_table[] if all of the fragments have not already been received or, if all of the fragments have been received, reassembles the original ip packet from the fragments. For example, the following ip packet of length 3744 bytes is broken up in transit into 4 fragments of lengths 1480 bytes, 1480 bytes, and 784 bytes. The corresponding fragment offsets of the fragments are 0, 185, and 370 respectively (the "fragment offset" is the actual byte offset divided by 8). reassemble() will reassemble this original ip packet from the fragments it receives.



reassemble() is called by ip_port_arrive() and in turn calls find_ass_ent() and merge_frags().



A return value of NULL indicates that the packet to which the fragment belongs was not reassembled in its entirety or that the reassembly time exceeded the maximum time allowed (255 seconds in Minix).

An example is a good way to see how reassemble() works.

Let's say that an ip packet is broken up into four fragments: fragments 1,2,3, and 4. Let's also say that the fragments arrive in the order 2 - 4 - 3 - 1.

When fragment 2 arrives, reassemble() on line 42090 adds fragment 2 to the head of the fragment linked list of an ip_ass_table[] element and returns NULL, indicating the the packet has not been reassembled.



When fragment 4 arrives, reassemble() is called again and on line 42125 calls merge_frags(), which links the two fragments together by the acc_ext_link field. Note that merge_frags() does not actually merge the fragments here since 2 and 4 are not consecutive fragments.



When fragment 1 arrives, reassemble() is called again and, on line 42118, reassemble() calls merge_frags(). This time, merge_frags() merges fragments 1 and 2.



When fragment 3 arrives, reassemble() is called again and, on line 42123, merge_frags() merges the combined fragment 1-2 with fragment 3.



Then, on line 42125, merge_frags() is called again to merge the combined fragment 1-2-3 with fragment 4.



At the end of this last call, reassemble() returns the reassembled packet.

find_ass_ent() / ip_ass_table[]

If an ip packet is fragmented, ip_ass_table[] (the ip assemble table) holds the fragments until they are reassembled by reassemble(). Each of the 3 elements (which is an oddly small number) of ip_ass_table[] corresponds to a packet that has been fragmented and is of type ip_ass_t (see below). find_ass_ent() searches through ip_ass_table[] for fragments of the same packet and adds the fragment to this packet if found and starts a new packet otherwise. If ip_ass_table[] is full, the oldest fragmented packet is dropped and replaced by the new fragmented packet and an icmp packet is sent to the source of the dropped packet.

typedef struct ip_ass

{

	acc_t *ia_frags;

	int ia_min_ttl;

	ip_port_t *ia_port;

	time_t ia_first_time;

	ipaddr_t ia_srcaddr, ia_dstaddr;

	int ia_proto, ia_id;

} ip_ass_t;

acc_t *ia_frags: The first fragment in the linked list of fragments. These accessors hold the data contained in the fragments and are linked by the accessors' acc_ext_link field.

int ia_min_ttl: Set to IP_MAX_TTL (#define'd as 255 in in.h). This value is in seconds and is the maximum time that a fragmented packet may be in ip_ass_table[] before the source is sent an icmp packet.

ip_port_t *ia_port: The ip port on which the packet arrived.

time_t ia_first_time: The time at which the first fragment of the packet is added.

ipaddr_t ia_srcaddr, ia_dstaddr: The source and destination ip address of the fragment.

int ia_proto: The protocol of the packet to which the fragment belongs. For example, if the packet is a udp packet, ia_proto will be 17. If the packet is a tcp packet, ia_proto will be 6.

ia_id: The value of the ih_id field for the ip header of the first packet sent out is determined by ip_init() and is equal to the number of clock ticks since reboot (i.e., the value returned by get_time) and is incremented for each packet sent out. This value is used to combine fragments at the receiving end if fragmentation has occurred. More specifically, if a packet is fragmented during transit, ia_id will be the same for all the fragments.

find_ass_ent() on the previous line found either a fragmented packet to which this fragment belonged or it claimed a slot in the ip_ass_table[] in which to start collecting a new fragmented packet.

Lines 42082 and 42085 calculate the byte offset of the fragment while lines 42083 and 42084 calculate the length of the fragment's data (which does not include the header).


ip_hdr_t

struct ip_hdr_t is the structure of an ip header. "ih" (e.g., ih_src, ih_dst) stands for "Ip Header".

ip_hdr_t is declared in /include/net/gen/ip_hdr.h:

typedef struct ip_hdr

{

         u8_t ih_vers_ihl, ih_tos;

         u16_t ih_length, ih_id, ih_flags_fragoff;

         u8_t ih_ttl, ih_proto;

         u16_t ih_hdr_chk;

         ipaddr_t ih_src, ih_dst;

} ip_hdr_t;

ih_vers_ihl: The lower 4 bits is the length of the header plus options (if there are any) shifted by 2 bit positions (i.e., its actual length is 4 times as great as the value stored in ih_vers_ihl). An example of an option is a router list that a packet should follow to its destination.

The upper four bits is the version number (e.g., IPv4).


ih_tos: tos stands for "Type Of Service" and is the priority of the ip packet. A value of zero is the lowest priority. Both UDP and TCP have a default TOS of zero.

#define TCP_DEF_TOS 0
#define UDP_TOS 0


ih_length: The length of the entire ip packet, including the ip header.


ih_id: The value of ih_id for the first packet sent out is determined by ip_init() and is equal to the number of clock ticks since reboot (i.e., the value returned by get_time) and is incremented for each packet sent out. This value is used to combine fragments at the receiving end if fragmentation has occurred.


ih_flags_fragoff: ih_flags_fragoff is a combination of flags and a (possible) fragmentation offset ("fragoff").

If the packet should not be fragmented, ih_flags_fragoff is set to IH_DONT_FRAG. If there are additional fragments (e.g., the 3rd fragment of 4 fragments), ih_flags_fragoff is set to IH_MORE_FRAGS.

If the packet is indeed just a fragment of a packet, this value indicates the starting byte position (in 8 byte increments) of the original ip packet's data. So for example, if an ip packet of data size (not including the ip header) is broken up into two fragments of 1496 and 504 bytes each, the first fragment would have a fragmentation offset of 0 bytes and the second fragment would have a fragmentation offset of 1496 bytes and ih_flags_fragoff is therefore 187 (1496 / 8 = 187).


ih_ttl: "Time to live" for the packet. As a packet is routed to the destination, each router decrements the packet's ttl. When the ttl reaches 0, the router sends an "icmp unreachable" packet to the source. The ttl is designed to prevent packets that can't reach their destination from indefinitely bouncing around between routers. UDP's default TTL is 30:

#define UDP_TTL 30

Note that the Minix code also uses this value as a timeout value (in seconds). This code was written before the ttl field was redefined to be strictly a hope count. The original IP RFC defines the ttl field as the time to live in seconds.


ih_proto: The protocol of the ip packet. For example, if the packet is a udp packet, ih_proto will be 17. If the packet is a tcp packet, ih_proto will be 6.


ih_hdr_chk: Checksum for the header.


ih_src, ih_dst: Source and destination ip address of the ip packet.

             IP HEADER (as given by RFC 791)           

   



    0                   1                   2                   3   

    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 

   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

   |Version|  IHL  |Type of Service|          Total Length         |

   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

   |         Identification        |Flags|      Fragment Offset    |

   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

   | Time to Live  |   Protocol    |   Header Checksum             |

   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

   |                       Source Address                          |

   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

   |                    Destination Address                        |

   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

   |                    Options                    |    Padding    |

   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

htons() / ntohs() / htonl() / ntohl()

From htons(3):

"htons() converts a 16-bit quantity from host byte order to network byte order."

Different CPU architectures group multiple bytes differently. For example, on a "little-endian" machine (an example of which is the Intel CPU), the value 0x1234 is stored in memory as 0x3412. However, on a "big-endian" machine, the value 0x1234 is stored in memory as 0x1234.

It is important that values in a header are sent across a network in a consistent manner independent of the architecture of the sending or receiving system. For this reason, a standard was chosen. The standard chosen was big-endian although it could have just as well been little-endian.

htons() is defined in /include/net/hton.h, as:
#define htons(x) (_tmp=(x), ((_tmp>>8) & 0xff) | ((_tmp<<8) & 0xff00))

ntohs() converts a 16-bit quantity from network byte order to host byte order, the reverse of htons().

htonl() and ntohl() are identical to htons() and ntohs() except that they convert 32-bit quantities instead of 16-bit quantities.

Processes generally supply header information when sending packets. The data in these fields is converted to the network format (i.e., big-endian) by the process before the process copies the data to the network service.

IH_IHL_MASK is defined in /include/net/gen/ip_hdr.h:

#define IH_IHL_MASK 0xf

htons() / ntohs() / htonl() / ntohl()

From htons(3):

"htons() converts a 16-bit quantity from host byte order to network byte order."

Different CPU architectures group multiple bytes differently. For example, on a "little-endian" machine (an example of which is the Intel CPU), the value 0x1234 is stored in memory as 0x3412. However, on a "big-endian" machine, the value 0x1234 is stored in memory as 0x1234.

It is important that values in a header are sent across a network in a consistent manner independent of the architecture of the sending or receiving system. For this reason, a standard was chosen. The standard chosen was big-endian although it could have just as well been little-endian.

htons() is defined in /include/net/hton.h, as:
#define htons(x) (_tmp=(x), ((_tmp>>8) & 0xff) | ((_tmp<<8) & 0xff00))

ntohs() converts a 16-bit quantity from network byte order to host byte order, the reverse of htons().

htonl() and ntohl() are identical to htons() and ntohs() except that they convert 32-bit quantities instead of 16-bit quantities.

Processes generally supply header information when sending packets. The data in these fields is converted to the network format (i.e., big-endian) by the process before the process copies the data to the network service.

IH_FRAGOFF_MASK is defined in /include/net/gen/ip_hdr.h:

#define IH_FRAGOFF_MASK 0x1fff

The fragments (which are stored in accessors) are linked together by their acc_ext_link field. The fragments are eventually reassembled to form a single accessor.

If head_acc is empty (i.e., no previous fragments of the same packet were found), the current fragment is placed in ip_ass_table[] and NULL is returned to indicate that the fragmented packet was not reassembled in its entirety.

This while loop finds the appropriate place in the linked list for the fragment based on its fragmentation offset. Note that this loop does not insert the fragment into the linked list. merge_frags() does that later.

Each fragment has an ip header.


ptr2acc_data()

The macro ptr2acc_data is #define'd in inet/generic/buf.h as:

#define ptr2acc_data(/* acc_t * */ a) (bf_temporary_acc=(a), \
(&bf_temporary_acc->acc_buffer->buf_data_p[bf_temporary_acc-> \
acc_offset]))

ptr2acc_data() simply returns a pointer to the actual data within an accessor.

ptr2acc_data() is usually called so that the fields of a header (e.g., ip header) can be analyzed.

htons() / ntohs() / htonl() / ntohl()

From htons(3):

"htons() converts a 16-bit quantity from host byte order to network byte order."

Different CPU architectures group multiple bytes differently. For example, on a "little-endian" machine (an example of which is the Intel CPU), the value 0x1234 is stored in memory as 0x3412. However, on a "big-endian" machine, the value 0x1234 is stored in memory as 0x1234.

It is important that values in a header are sent across a network in a consistent manner independent of the architecture of the sending or receiving system. For this reason, a standard was chosen. The standard chosen was big-endian although it could have just as well been little-endian.

htons() is defined in /include/net/hton.h, as:
#define htons(x) (_tmp=(x), ((_tmp>>8) & 0xff) | ((_tmp<<8) & 0xff00))

ntohs() converts a 16-bit quantity from network byte order to host byte order, the reverse of htons().

htonl() and ntohl() are identical to htons() and ntohs() except that they convert 32-bit quantities instead of 16-bit quantities.

Processes generally supply header information when sending packets. The data in these fields is converted to the network format (i.e., big-endian) by the process before the process copies the data to the network service.

Swap the two fragments. Recall that the fragments are linked together by their acc_ext_link fields.

If the fragment became the first in the linked list, attempt to merge the first fragment with the second fragment.

merge_frags()

merge_frags(first, second) attempts to merge fragments first, the first parameter, with second, the second parameter. If the fragments are not consecutive fragments (for example, if the two fragments are the 2nd and 4th fragments of the original packet), merge_frags() simply links the two fragments together.

If the fragment is somewhere in the middle, attempt to merge the fragment with both the fragment before it and the fragment after it.

merge_frags()

merge_frags(first, second) attempts to merge fragments first, the first parameter, with second, the second parameter. If the fragments are not consecutive fragments (for example, if the two fragments are the 2nd and 4th fragments of the original packet), merge_frags() simply links the two fragments together.

merge_frags()

merge_frags(first, second) attempts to merge fragments first, the first parameter, with second, the second parameter. If the fragments are not consecutive fragments (for example, if the two fragments are the 2nd and 4th fragments of the original packet), merge_frags() simply links the two fragments together.

Place the new fragment (which will be the result of a merge of two or more fragments) in the appropriate position in the linked list of fragments.

Lines 42131-42135 retrieve the ih_flags_fragoff field from the first fragment in the relevant ip_ass_table[] element so that it can be examined on line 42137.

The ia_frags field for an element in ip_ass_table[] points to the first fragment in the linked list of fragments.

ptr2acc_data()

The macro ptr2acc_data is #define'd in inet/generic/buf.h as:

#define ptr2acc_data(/* acc_t * */ a) (bf_temporary_acc=(a), \
(&bf_temporary_acc->acc_buffer->buf_data_p[bf_temporary_acc-> \
acc_offset]))

ptr2acc_data() simply returns a pointer to the actual data within an accessor.

ptr2acc_data() is usually called so that the fields of a header (e.g., ip header) can be analyzed.

htons() / ntohs() / htonl() / ntohl()

From htons(3):

"htons() converts a 16-bit quantity from host byte order to network byte order."

Different CPU architectures group multiple bytes differently. For example, on a "little-endian" machine (an example of which is the Intel CPU), the value 0x1234 is stored in memory as 0x3412. However, on a "big-endian" machine, the value 0x1234 is stored in memory as 0x1234.

It is important that values in a header are sent across a network in a consistent manner independent of the architecture of the sending or receiving system. For this reason, a standard was chosen. The standard chosen was big-endian although it could have just as well been little-endian.

htons() is defined in /include/net/hton.h, as:
#define htons(x) (_tmp=(x), ((_tmp>>8) & 0xff) | ((_tmp<<8) & 0xff00))

ntohs() converts a 16-bit quantity from network byte order to host byte order, the reverse of htons().

htonl() and ntohl() are identical to htons() and ntohs() except that they convert 32-bit quantities instead of 16-bit quantities.

Processes generally supply header information when sending packets. The data in these fields is converted to the network format (i.e., big-endian) by the process before the process copies the data to the network service.

If there are no more fragments after the first fragment (i.e., its IH_MORE_FRAGS flag is not set), the packet has been completely reassembled. Unless it took too long to reassemble the packet (see lines 42151-42154), return the newly reassembled packet to ip_port_arrive().


IH_FRAGOFF_MASK and IH_MORE_FRAGS are #define'd in /include/net/gen/ip_hdr.h:

#define IH_FRAGOFF_MASK 0x1fff
#define IH_MORE_FRAGS 0x2000

The variable first_time is used on line 42151 to determine if it has taken too long (in the case of Minix, 255 seconds) to reassemble the packet.

The next two lines free up the ip_ass_table[] element.

Free up any accessors that are unnecessarily linked to the packet (for example, a fragment that was sent twice).

bf_afree()

After a chain of accessors is no longer needed, the chain (and not simply the single accessor passed as the parameter) can be freed by calling bf_free(). However, if either acc_linkC or buf_linkC of one of the accessors in the linked list is not equal to one (1), the entire chain will not be freed. For example, if buf_afree(acc1) is called for the following chain:



Then the resulting chain will be:



bf_afree() returns acc1 (accessors[63]) to acc_freelist (recall that acc_freelist is the linked list of acc_t's without an associated buffer). However, buffers512[127] cannot be freed because acc2 (accessors[64]) still references it.

bf_afree() is called after an accessor's associated data is no longer needed (for example, after a packet has been sent off by the ethernet driver).

get_time()

get_time() returns the number of clock ticks since reboot.

Several of the clients (eth, arp, ip, tcp, and udp) use get_time() to determine an appropriate timeout value for a given operation. For example, the arp code calls get_time() to determine an appropriate amount of time to wait for a response from an arp request before giving up.

If it took too long to reassemble the packet, send an icmp packet to the source.

ICMP_FRAG_REASSEM is #define'd in /include/net/gen/icmp.h:

# define ICMP_FRAG_REASSEM 1

and is the code number for the "Fragment Reassembly Time Exceeded" message.


icmp_time_exceeded()

icmp_time_exceeded() is called by process_data() to handle time-exceeded icmp messages.

If the icmp message is valid, ipr_ttl_exc() is called to either increase the ttl of the appropriate entry in the output routing table or mark the entry as unreachable.

The packet was successfully reassembled. Return the packet to ip_port_arrive().

If the original packet was not completely reassembled, return NULL. It will have to wait for the remaining fragments (unless the process timed out).

merge_frags()

merge_frags(first, second) attempts to merge fragments first, the first parameter, with second, the second parameter. If the fragments are not consecutive fragments (for example, if the two fragments are the 2nd and 4th fragments of the original packet), merge_frags() simply links the two fragments together.

If there isn't a second fragment with which to merge the first, there isn't much that can be done.

Lines 42178-42182 determine the first fragment's data length (not including the header) and its fragmentation offset. Lines 42184-42188 determine the second fragment's data length (again, not including the header) and its fragmentation offset. These values are ascertained from the fragments' ip headers.


ip_hdr_t

struct ip_hdr_t is the structure of an ip header. "ih" (e.g., ih_src, ih_dst) stands for "Ip Header".

ip_hdr_t is declared in /include/net/gen/ip_hdr.h:

typedef struct ip_hdr

{

         u8_t ih_vers_ihl, ih_tos;

         u16_t ih_length, ih_id, ih_flags_fragoff;

         u8_t ih_ttl, ih_proto;

         u16_t ih_hdr_chk;

         ipaddr_t ih_src, ih_dst;

} ip_hdr_t;

ih_vers_ihl: The lower 4 bits is the length of the header plus options (if there are any) shifted by 2 bit positions (i.e., its actual length is 4 times as great as the value stored in ih_vers_ihl). An example of an option is a router list that a packet should follow to its destination.

The upper four bits is the version number (e.g., IPv4).


ih_tos: tos stands for "Type Of Service" and is the priority of the ip packet. A value of zero is the lowest priority. Both UDP and TCP have a default TOS of zero.

#define TCP_DEF_TOS 0
#define UDP_TOS 0


ih_length: The length of the entire ip packet, including the ip header.


ih_id: The value of ih_id for the first packet sent out is determined by ip_init() and is equal to the number of clock ticks since reboot (i.e., the value returned by get_time) and is incremented for each packet sent out. This value is used to combine fragments at the receiving end if fragmentation has occurred.


ih_flags_fragoff: ih_flags_fragoff is a combination of flags and a (possible) fragmentation offset ("fragoff").

If the packet should not be fragmented, ih_flags_fragoff is set to IH_DONT_FRAG. If there are additional fragments (e.g., the 3rd fragment of 4 fragments), ih_flags_fragoff is set to IH_MORE_FRAGS.

If the packet is indeed just a fragment of a packet, this value indicates the starting byte position (in 8 byte increments) of the original ip packet's data. So for example, if an ip packet of data size (not including the ip header) is broken up into two fragments of 1496 and 504 bytes each, the first fragment would have a fragmentation offset of 0 bytes and the second fragment would have a fragmentation offset of 1496 bytes and ih_flags_fragoff is therefore 187 (1496 / 8 = 187).


ih_ttl: "Time to live" for the packet. As a packet is routed to the destination, each router decrements the packet's ttl. When the ttl reaches 0, the router sends an "icmp unreachable" packet to the source. The ttl is designed to prevent packets that can't reach their destination from indefinitely bouncing around between routers. UDP's default TTL is 30:

#define UDP_TTL 30

Note that the Minix code also uses this value as a timeout value (in seconds). This code was written before the ttl field was redefined to be strictly a hope count. The original IP RFC defines the ttl field as the time to live in seconds.


ih_proto: The protocol of the ip packet. For example, if the packet is a udp packet, ih_proto will be 17. If the packet is a tcp packet, ih_proto will be 6.


ih_hdr_chk: Checksum for the header.


ih_src, ih_dst: Source and destination ip address of the ip packet.

             IP HEADER (as given by RFC 791)           

   



    0                   1                   2                   3   

    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 

   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

   |Version|  IHL  |Type of Service|          Total Length         |

   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

   |         Identification        |Flags|      Fragment Offset    |

   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

   | Time to Live  |   Protocol    |   Header Checksum             |

   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

   |                       Source Address                          |

   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

   |                    Destination Address                        |

   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

   |                    Options                    |    Padding    |

   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

ptr2acc_data()

The macro ptr2acc_data is #define'd in inet/generic/buf.h as:

#define ptr2acc_data(/* acc_t * */ a) (bf_temporary_acc=(a), \
(&bf_temporary_acc->acc_buffer->buf_data_p[bf_temporary_acc-> \
acc_offset]))

ptr2acc_data() simply returns a pointer to the actual data within an accessor.

ptr2acc_data() is usually called so that the fields of a header (e.g., ip header) can be analyzed.

htons() / ntohs() / htonl() / ntohl()

From htons(3):

"htons() converts a 16-bit quantity from host byte order to network byte order."

Different CPU architectures group multiple bytes differently. For example, on a "little-endian" machine (an example of which is the Intel CPU), the value 0x1234 is stored in memory as 0x3412. However, on a "big-endian" machine, the value 0x1234 is stored in memory as 0x1234.

It is important that values in a header are sent across a network in a consistent manner independent of the architecture of the sending or receiving system. For this reason, a standard was chosen. The standard chosen was big-endian although it could have just as well been little-endian.

htons() is defined in /include/net/hton.h, as:
#define htons(x) (_tmp=(x), ((_tmp>>8) & 0xff) | ((_tmp<<8) & 0xff00))

ntohs() converts a 16-bit quantity from network byte order to host byte order, the reverse of htons().

htonl() and ntohl() are identical to htons() and ntohs() except that they convert 32-bit quantities instead of 16-bit quantities.

Processes generally supply header information when sending packets. The data in these fields is converted to the network format (i.e., big-endian) by the process before the process copies the data to the network service.

second_offset is the fragmentation offset of the second fragment.


htons() / ntohs() / htonl() / ntohl()

From htons(3):

"htons() converts a 16-bit quantity from host byte order to network byte order."

Different CPU architectures group multiple bytes differently. For example, on a "little-endian" machine (an example of which is the Intel CPU), the value 0x1234 is stored in memory as 0x3412. However, on a "big-endian" machine, the value 0x1234 is stored in memory as 0x1234.

It is important that values in a header are sent across a network in a consistent manner independent of the architecture of the sending or receiving system. For this reason, a standard was chosen. The standard chosen was big-endian although it could have just as well been little-endian.

htons() is defined in /include/net/hton.h, as:
#define htons(x) (_tmp=(x), ((_tmp>>8) & 0xff) | ((_tmp<<8) & 0xff00))

ntohs() converts a 16-bit quantity from network byte order to host byte order, the reverse of htons().

htonl() and ntohl() are identical to htons() and ntohs() except that they convert 32-bit quantities instead of 16-bit quantities.

Processes generally supply header information when sending packets. The data in these fields is converted to the network format (i.e., big-endian) by the process before the process copies the data to the network service.

If a fragment is missing between the two fragments, just link the two fragments together. For example, if the fragmentation offset of the first fragment is 500 bytes and its data length is 500 bytes and the second fragment has a fragmentation offset of 1500 bytes, there is a gap of 500 bytes between the two fragments.

If the first fragment is after the second fragment in the original datagram, it is better to delete the first fragment. merge_frags() expects the fragment first to really be the first fragment.

bf_afree()

After a chain of accessors is no longer needed, the chain (and not simply the single accessor passed as the parameter) can be freed by calling bf_free(). However, if either acc_linkC or buf_linkC of one of the accessors in the linked list is not equal to one (1), the entire chain will not be freed. For example, if buf_afree(acc1) is called for the following chain:



Then the resulting chain will be:



bf_afree() returns acc1 (accessors[63]) to acc_freelist (recall that acc_freelist is the linked list of acc_t's without an associated buffer). However, buffers512[127] cannot be freed because acc2 (accessors[64]) still references it.

bf_afree() is called after an accessor's associated data is no longer needed (for example, after a packet has been sent off by the ethernet driver).

Since the first fragment will be merged with the second fragment, turn off the IH_MORE_FRAGS in the first fragment if there will be no fragments after the second fragment.


htons() / ntohs() / htonl() / ntohl()

From htons(3):

"htons() converts a 16-bit quantity from host byte order to network byte order."

Different CPU architectures group multiple bytes differently. For example, on a "little-endian" machine (an example of which is the Intel CPU), the value 0x1234 is stored in memory as 0x3412. However, on a "big-endian" machine, the value 0x1234 is stored in memory as 0x1234.

It is important that values in a header are sent across a network in a consistent manner independent of the architecture of the sending or receiving system. For this reason, a standard was chosen. The standard chosen was big-endian although it could have just as well been little-endian.

htons() is defined in /include/net/hton.h, as:
#define htons(x) (_tmp=(x), ((_tmp>>8) & 0xff) | ((_tmp<<8) & 0xff00))

ntohs() converts a 16-bit quantity from network byte order to host byte order, the reverse of htons().

htonl() and ntohl() are identical to htons() and ntohs() except that they convert 32-bit quantities instead of 16-bit quantities.

Processes generally supply header information when sending packets. The data in these fields is converted to the network format (i.e., big-endian) by the process before the process copies the data to the network service.

The remainder of merge_frags() cuts out the second fragment's header and any overlap between the two fragments (see figure for comment for line 42215) and appends the remainder of the second fragment to the first fragment. In addition to this, merge_frags() also adjusts the ih_length field (the total length of the fragment including the header) of the new, larger first fragment and adjusts this fragment's acc_ext_link field (see line 42224).

Cut out at least the second fragment's header and, if there is some overlap between the two fragments, cut out the length of the overlap in the second fragment's data:






bf_cut()

If a section of a linked list needs to be duplicated, bf_cut(data, offset, length) is called. For example, if a section of length 50 starting at an offset of 75 of the linked list below needs to be duplicated, bf_cut(data, 75, 50) is called:



Note that the original linked list remains unchanged and that acc_linkC for all the accessors in the new linked list is one.

If length (the second parameter) is zero, simply duplicate the first accessor in the linked list but set acc_length=0 and acc_next=null. In other words, create a linked list of length one accessor whose acc_length is 0.

bf_cut() is used in a number of scenarios, including cutting a received ethernet packet to size.

For a full description of the network service's buffer management, click here.

Adjust the first fragment's ih_length field (the total length of the fragment including the header).

This is where the actual merging occurs.


bf_append()

bf_append() appends one accessor linked list to another accessor linked list. For example, if the payload of an ethernet packet (1500 bytes) is appended to an ethernet header (14 bytes):



the resulting linked list is as follows:

The next fragment in the linked list for the first framgent is the fragment that was originally the next fragment for the second fragment (which no longer exists).

The merged fragment is returned.

find_ass_ent() / ip_ass_table[]

If an ip packet is fragmented, ip_ass_table[] (the ip assemble table) holds the fragments until they are reassembled by reassemble(). Each of the 3 elements (which is an oddly small number) of ip_ass_table[] corresponds to a packet that has been fragmented and is of type ip_ass_t (see below). find_ass_ent() searches through ip_ass_table[] for fragments of the same packet and adds the fragment to this packet if found and starts a new packet otherwise. If ip_ass_table[] is full, the oldest fragmented packet is dropped and replaced by the new fragmented packet and an icmp packet is sent to the source of the dropped packet.

typedef struct ip_ass

{

	acc_t *ia_frags;

	int ia_min_ttl;

	ip_port_t *ia_port;

	time_t ia_first_time;

	ipaddr_t ia_srcaddr, ia_dstaddr;

	int ia_proto, ia_id;

} ip_ass_t;

acc_t *ia_frags: The first fragment in the linked list of fragments. These accessors hold the data contained in the fragments and are linked by the accessors' acc_ext_link field.

int ia_min_ttl: Set to IP_MAX_TTL (#define'd as 255 in in.h). This value is in seconds and is the maximum time that a fragmented packet may be in ip_ass_table[] before the source is sent an icmp packet.

ip_port_t *ia_port: The ip port on which the packet arrived.

time_t ia_first_time: The time at which the first fragment of the packet is added.

ipaddr_t ia_srcaddr, ia_dstaddr: The source and destination ip address of the fragment.

int ia_proto: The protocol of the packet to which the fragment belongs. For example, if the packet is a udp packet, ia_proto will be 17. If the packet is a tcp packet, ia_proto will be 6.

ia_id: The value of the ih_id field for the ip header of the first packet sent out is determined by ip_init() and is equal to the number of clock ticks since reboot (i.e., the value returned by get_time) and is incremented for each packet sent out. This value is used to combine fragments at the receiving end if fragmentation has occurred. More specifically, if a packet is fragmented during transit, ia_id will be the same for all the fragments.

Search through ip_ass_table[] (which has only 3 elements).

If the fragment has the same source address, destination address, protocol, ip port, and (probably most importantly) id, a match has been found. Return the ip_ass_table[] element (which corresponds to a fragmented packet) to reassemble(). reassemble() will then possibly add the new fragment to the ip_ass_table[] element or possibly reassemble the packet (among other possibilities).

Keep track of which element has been in ip_ass_table[] the longest. If ip_ass_table[] is full, this element will be discarded (see the block on lines 42269-42288).

If ip_ass_table[] is full, the fragmented packet that has been in ip_ass_table[] for the longest time is discarded and the source is sent an icmp packet.

Free all the accessors (except for the first one which is used to send an icmp packet back to the source) that were used to hold the fragmented packet's data.

bf_afree()

After a chain of accessors is no longer needed, the chain (and not simply the single accessor passed as the parameter) can be freed by calling bf_free(). However, if either acc_linkC or buf_linkC of one of the accessors in the linked list is not equal to one (1), the entire chain will not be freed. For example, if buf_afree(acc1) is called for the following chain:



Then the resulting chain will be:



bf_afree() returns acc1 (accessors[63]) to acc_freelist (recall that acc_freelist is the linked list of acc_t's without an associated buffer). However, buffers512[127] cannot be freed because acc2 (accessors[64]) still references it.

bf_afree() is called after an accessor's associated data is no longer needed (for example, after a packet has been sent off by the ethernet driver).

Send the source of the discarded packet an icmp packet.


icmp_snd_time_exceeded()

icmp_snd_time_exceeded() sends an ICMP_TYPE_TIME_EXCEEDED icmp message. ICMP_TYPE_TIME_EXCEEDED messages are sent when either a packet's TTL timer has expired or if some fragments of the original packet were not received in time to be reassembled by the destination system.

Add the fragment (which will be the first from the original packet) to the (perhaps newly) unoccupied element of ip_ass_table[] and return the element.

Minix chooses a max ttl value of 255 seconds as the reassembly timeout while many other implementations (e.g., at BSD - see TCP Illustrated vol II, pp 292) use a value of 60 seconds. RFC 1122 recommends a value between 60 and 120 seconds (and requires that an icmp time exceeded message be sent back to the source).

Note that this value is in seconds and not in hops.

get_time()

get_time() returns the number of clock ticks since reboot.

Several of the clients (eth, arp, ip, tcp, and udp) use get_time() to determine an appropriate timeout value for a given operation. For example, the arp code calls get_time() to determine an appropriate amount of time to wait for a response from an arp request before giving up.

ip_frag_chk()

ip_frag_chk(pack) performs a few checks on the packet pack, ip_frag_chk()'s only parameter. For example, ip_frag_chk() verifies that the checksum of the ip header is zero.

ip_frag_chk() returns 0 on failure.

The length of the packet must be at least the length of an ip header.

ptr2acc_data()

The macro ptr2acc_data is #define'd in inet/generic/buf.h as:

#define ptr2acc_data(/* acc_t * */ a) (bf_temporary_acc=(a), \
(&bf_temporary_acc->acc_buffer->buf_data_p[bf_temporary_acc-> \
acc_offset]))

ptr2acc_data() simply returns a pointer to the actual data within an accessor.

ptr2acc_data() is usually called so that the fields of a header (e.g., ip header) can be analyzed.

The lower 4 bits of ih_vers_ihl is the length of the header plus options (if there are any) shifted by 2 bit positions (i.e., its actual length is 4 times as great as the value stored in ih_vers_ihl). An example of an option is a router list that a packet should follow to its destination.

The upper four bits is the version number (e.g., IPv4).

The packet length must be at least as great as the length of the ip header as reported in the ip header.

The upper four bits of ih_vers_ihl is the version number. This must be IPv4.

IP_VERSION is defined in /include/net/gen/in.h:

#define IP_VERSION 4

The length of the packet must be equal to the length of the entire packet as reported by the ip header (i.e., ih_length).


bf_bufsize()

bf_bufsize() returns the total buffer size of a linked list of accessors (i.e., the sum of acc_length for the accessors in a linked list).

For a detailed description of the network service's buffer management, click here.


htons() / ntohs() / htonl() / ntohl()

From htons(3):

"htons() converts a 16-bit quantity from host byte order to network byte order."

Different CPU architectures group multiple bytes differently. For example, on a "little-endian" machine (an example of which is the Intel CPU), the value 0x1234 is stored in memory as 0x3412. However, on a "big-endian" machine, the value 0x1234 is stored in memory as 0x1234.

It is important that values in a header are sent across a network in a consistent manner independent of the architecture of the sending or receiving system. For this reason, a standard was chosen. The standard chosen was big-endian although it could have just as well been little-endian.

htons() is defined in /include/net/hton.h, as:
#define htons(x) (_tmp=(x), ((_tmp>>8) & 0xff) | ((_tmp<<8) & 0xff00))

ntohs() converts a 16-bit quantity from network byte order to host byte order, the reverse of htons().

htonl() and ntohl() are identical to htons() and ntohs() except that they convert 32-bit quantities instead of 16-bit quantities.

Processes generally supply header information when sending packets. The data in these fields is converted to the network format (i.e., big-endian) by the process before the process copies the data to the network service.

oneC_sum()

A checksum is used to determine if errors occurred during the transmission of data. The checksum algorithm used by oneC_sum() (which is also the Internet standard) is described by RFC 1071.

Essentially, the algorithm goes through data and adds all the bytes together (using one's complement addition). The high 16 bits of the resulting 32 bit value is then added to the low 16 bits (again, using one's complement addition). The checksum field is then set to the one's complement of this 16 bit sum. (Recall that the one's complement of 0xF0F0 is 0x0F0F.) Since AND'ing any 16 bit number and its 16 bit one's complement will equal 0xFFFF, the checksum of the packet (without the checksum field) AND'ed with the checksum field will equal 0xFFFF (provided the packet was not corrupted after the checksum field was calculated). For example, the checksum of a udp header (including the checksum field) will equal 0xFFFF if the packet was not corrupted in delivery.


From RFC 1071:

In outline, the Internet checksum algorithm is fairly simple:

(1) Adjacent octets to be checksummed are paired to form 16-bit
integers, and the 1's complement sum of these 16-bit integers is
formed.

(2) To generate a checksum, the checksum field itself is cleared,
the 16-bit 1's complement sum is computed over the octets
concerned, and the 1's complement of this sum is placed in the
checksum field.

(3) To check a checksum, the 1's complement sum is computed over the
same set of octets, including the checksum field. If the result
is all 1 bits (-0 in 1's complement arithmetic), the check
succeeds.

Below is a "C" code algorithm that describes the process above. This algorithm is also from RFC 1071. Note that count is the running count of all the bytes in the data and checksum is the return value.

       {

           /* Compute Internet Checksum for "count" bytes

            *         beginning at location "addr".

            */

       register long sum = 0;



        while( count > 1 )  {

           /*  This is the inner loop */

               sum += * (unsigned short) addr++;

               count -= 2;

       }



           /*  Add left-over byte, if any */

       if( count > 0 )

               sum += * (unsigned char *) addr;



           /*  Fold 32-bit sum to 16 bits */

       while (sum>>16)

           sum = (sum & 0xffff) + (sum >> 16);



       checksum = ~sum;

   }

Verify that the ip header length is greater than the minimum size and verify that the ip header options are acceptable.


ip_chk_hdropt()

ip_chk_hdropt() goes through the ip header options (if there are any) and verifies that the options are acceptable. For example, ip_chk_hdropt() verifies that the same ip header option is not listed twice.


ptr2acc_data()

The macro ptr2acc_data is #define'd in inet/generic/buf.h as:

#define ptr2acc_data(/* acc_t * */ a) (bf_temporary_acc=(a), \
(&bf_temporary_acc->acc_buffer->buf_data_p[bf_temporary_acc-> \
acc_offset]))

ptr2acc_data() simply returns a pointer to the actual data within an accessor.

ptr2acc_data() is usually called so that the fields of a header (e.g., ip header) can be analyzed.

packet2user() / ip

packet2user() attempts to pass a packet off to a higher layer (e.g., udp). If the ip file descriptor is not currently being read (i.e., the IFF_READ_IP flag in the if_flags field of the ip file descriptor is not set), packet2user() puts the packet at the end of its read queue and returns. Note that if the udp code opened the ip file descriptor, however, the udp code set the IFF_READ_IP flag during its initialization and that this flag remains set until the ip file descriptor is closed.

To fully understand packet2user(), an understanding of the network service's buffer management is necessary.


acc_freelist / buf512_freelist / accessors[] , buffers512[]

While being processed by the network service, packets and configuration data are temporarily stored in buffers associated with struct's named "accessors". These accessors are chained together to form linked lists and can be manipulated by a number of functions. There are two linked lists of signifigance in buf.c: acc_freelist and buf512_freelist. After initialization, these linked lists are as follows:



where the elements of buffers512[] are of type buf512_t:

typedef struct buf512 

{ 

          buf_t buf_header; 

          char buf_data[512];   /* the user data is found here */

} buf512_t



typedef struct buf

{

          int buf_linkC;

          buffree_t buf_free;

          size_t buf_size;

          char *buf_data_p;  

} buf_t;

and the elements of accessors[] are of type acc_t:

typedef struct acc

{

          int acc_linkC;

          int acc_offset, acc_length;

          buf_t *acc_buffer;

          struct acc *acc_next, *acc_ext_link;

} acc_t;

The fields of these struct's are described in the context of the functions that access them.

buf512_freelist is the linked list of accessors that have associated buffers and acc_freelist is the linked list of accessors that do not have associated buffers. When a buffer is needed, an accessor from buf512_freelist is taken (see bf_memreq() below). When a single accessor or a segment of the linked list is duplicated, the duplicate accessor is taken from acc_freelist (see bf_dupacc() and bf_cut() below).

If an accessor is at the beginning of a linked list or if only a single accessor is referencing it, acc_linkC will be one. If more than one accessor references another accessor, however, acc_linkC for the referenced accessor will be greater than one. Similarly, if only a single accessor references a buffer, buf_linkC will be one. If more than one accessor references a buffer, the buffer's buf_linkC will be greater than one. For two good examples of functions that affect acc_linkC/buf_linkC, see bf_dupacc() and bf_cut() below.

As with other queues within the network service, the memory for the acc_freelist queue and the buf512_freelist queue (and its associated buffers) come from arrays with a limited number of elements. This must be done because memory within Minix is scarce (for one reason, Minix does not have virtual memory).

When buffer space for data is needed (for example, for an incoming ethernet packet), bf_memreq() is called to acquire the space. For example, if ETH_MAX_PACK_SIZE (#define'd as 1514) bytes of buffer space are required, bf_memreq() will remove 3 accessors from buf512_freelist and will return a pointer to the first accessor:



If an accessor needs to be duplicated, bf_dupacc() is called. For example, if acc (see figure below) is needed to be duplicated, bf_dupacc(acc) will return new_acc:



Note that the buf_linkC of buffers512[127] and the acc_linkC of accessors[65] are incremented to 2. Also note that the accessor returned by bf_dupacc() (in this case, new_acc) is taken from acc_freelist and not from buf512_freelist.

After a chain of accessors is no longer needed, the chain can be freed by calling bf_free(). However, if either acc_linkC or buf_linkC of one of the accessors or their associated buffers in the linked list is not equal to one, then the entire chain will not be freed. For example, if buf_afree(acc1) is called for the following chain:



Then the resulting chain will be:



bf_afree() returns acc1 (accessors[63]) to acc_freelist (recall that acc_freelist is the linked list of acc_t's without an associated buffer). However, buffers512[127] cannot be freed because acc2 (accessors[64]) still references it.

bf_afree() is called after an accessor's associated data is no longer needed (for example, after a packet has been sent off by the ethernet driver).

If a section of a linked list needs to be duplicated (as opposed to a single accessor - see bf_dupacc() above), bf_cut() is called. For example, if a section of length 50 starting at an offset of 75 of the linked list below needs to be duplicated, bf_cut(data, 75, 50) is called:



bf_cut() is used in a number of scenarios, including cutting a received ethernet packet to size. bf_afree() is generally called after bf_cut() to free up the original accessor linked list.

If only the beginning of a linked list can be freed, bf_delhead() is called. If acc_linkC and buf_linkC are one for all of the relevant accessors and their associated buffers in the linked list, the operation is straight-forward:



bf_delhead() is often called to remove the header (e.g., ip header) from a packet. Note that the buffers of the accessors returned to the buf512_freelist have their buf_linkC field set to zero (0).

bf_append() appends one accessor linked list to another accessor linked list. For example, if the payload of an ethernet packet (1500 bytes) is appended to an ethernet header (14 bytes):



the resulting linked list is as follows:



If data is not already packed and aligned, bf_align(acc, size, alignment) packs SIZE bytes from ACC, a linked list of accessors, by calling bf_pack(). This packing is necessary to ensure that all of the fields from a header are easily accessed. For example, the ip code aligns a packet's header contained in the accessors before accessing the various ip header fields.

If the ip file descriptor is currently not being read (i.e., the IFF_READ_IP flag is not set), place the packet at the end of its read queue and set the expiration time. The IFF_READ_IP flag was set on line 42046 by ip_read().

Place the packet at the tail of the read queue (which is also the head of the queue if there were no packets previously in the queue).

This expiration time is checked on line 42049 by ip_read().

From ip(4):

"NWIO_RWDATONLY specifies that the header should be omitted from a write request...A read operation will also only return the data part, so the IP options will be lost."

Remove the ip header from the packet. The process that made the read request doesn't want it.


bf_delhead()

If only the beginning of a linked list can be freed, bf_delhead() is called. If acc_linkC and buf_linkC are one for all of the relevant accessors and their associated buffers in the linked list, the operation is straight-forward:



bf_delhead() is often called to remove the header (e.g., ip header) from a packet.

For a detailed description of the network service's buffer management, click here.

Make sure that the higher layer (e.g., udp) doesn't receive more data than it requested.

bf_cut()

If a section of a linked list needs to be duplicated, bf_cut(data, offset, length) is called. For example, if a section of length 50 starting at an offset of 75 of the linked list below needs to be duplicated, bf_cut(data, 75, 50) is called:



Note that the original linked list remains unchanged and that acc_linkC for all the accessors in the new linked list is one.

If length (the second parameter) is zero, simply duplicate the first accessor in the linked list but set acc_length=0 and acc_next=null. In other words, create a linked list of length one accessor whose acc_length is 0.

bf_cut() is used in a number of scenarios, including cutting a received ethernet packet to size.

For a full description of the network service's buffer management, click here.

bf_afree()

After a chain of accessors is no longer needed, the chain (and not simply the single accessor passed as the parameter) can be freed by calling bf_free(). However, if either acc_linkC or buf_linkC of one of the accessors in the linked list is not equal to one (1), the entire chain will not be freed. For example, if buf_afree(acc1) is called for the following chain:



Then the resulting chain will be:



bf_afree() returns acc1 (accessors[63]) to acc_freelist (recall that acc_freelist is the linked list of acc_t's without an associated buffer). However, buffers512[127] cannot be freed because acc2 (accessors[64]) still references it.

bf_afree() is called after an accessor's associated data is no longer needed (for example, after a packet has been sent off by the ethernet driver).

There are two functions (actually, they reference functions) that can send data to the higher layer: if_put_pkt and if_put_userdata. The if_put_pkt field of the ip file descriptor corresponds to a higher layer function (e.g., udp_ip_arrived) as does if_put_userdata (e.g., udp_put_data()). These two values were set by ip_open() (if_put_pkt corresponds to the fifth parameter and if_put_userdata corresponds to the fourth parameter). If if_put_pkt has been set, packet2user() calls it (actually, it calls the function that if_put_pkt references) and then returns. Otherwise, packet2user() calls if_put_userdata (again, it calls the function that if_put_userdata references).

if_put_pkt is not set for ip file descriptors opened by the icmp code. if_put_userdata is set to reference icmp_putdata().

Clear the IFF_READ_IP flag to indicate that the read operation is over. Note that this point in the code will never be reached if the ip file descriptor was opened by the udp code and so the ip file descriptor's IFF_READ_IP flag is never cleared.

ip_port_arrive()

For a given packet, ip_port_arrive() finds the ip file descriptors that are interested in the packet. ip_port_arrive() then hands the packet off to the higher layer (e.g., udp layer) by calling either packet2user() or a protocol-specific function (e.g., udp_ip_arrived()).

eth_arrive() is the function analogous to ip_port_arrive() on the ethernet layer. eth_arrive() tries to find interested ethernet file descriptors for a given packet.udp read path

eth_arrive() 

  ip_eth_arrived() 



    if (unicast packet)

      ip_arrived()

    else if (ethernet broadcast packet)

      ip_arrived_broadcast()



      if (packet must be input routed)

        hand off packet to destination ip port

      else 

        ip_port_arrive() {

          packet2user()

            udp_ip_arrived() 

        }

ip_port_arrive() examines the ip header fields closely. A careful study of the ip header's fields at this point is beneficial.


ip_hdr_t

struct ip_hdr_t is the structure of an ip header. "ih" (e.g., ih_src, ih_dst) stands for "Ip Header".

ip_hdr_t is declared in /include/net/gen/ip_hdr.h:

typedef struct ip_hdr

{

         u8_t ih_vers_ihl, ih_tos;

         u16_t ih_length, ih_id, ih_flags_fragoff;

         u8_t ih_ttl, ih_proto;

         u16_t ih_hdr_chk;

         ipaddr_t ih_src, ih_dst;

} ip_hdr_t;

ih_vers_ihl: The lower 4 bits is the length of the header plus options (if there are any) shifted by 2 bit positions (i.e., its actual length is 4 times as great as the value stored in ih_vers_ihl). An example of an option is a router list that a packet should follow to its destination.

The upper four bits is the version number (e.g., IPv4).


ih_tos: tos stands for "Type Of Service" and is the priority of the ip packet. A value of zero is the lowest priority. Both UDP and TCP have a default TOS of zero.

#define TCP_DEF_TOS 0
#define UDP_TOS 0


ih_length: The length of the entire ip packet, including the ip header.


ih_id: The value of ih_id for the first packet sent out is determined by ip_init() and is equal to the number of clock ticks since reboot (i.e., the value returned by get_time) and is incremented for each packet sent out. This value is used to combine fragments at the receiving end if fragmentation has occurred.


ih_flags_fragoff: ih_flags_fragoff is a combination of flags and a (possible) fragmentation offset ("fragoff").

If the packet should not be fragmented, ih_flags_fragoff is set to IH_DONT_FRAG. If there are additional fragments (e.g., the 3rd fragment of 4 fragments), ih_flags_fragoff is set to IH_MORE_FRAGS.

If the packet is indeed just a fragment of a packet, this value indicates the starting byte position (in 8 byte increments) of the original ip packet's data. So for example, if an ip packet of data size (not including the ip header) is broken up into two fragments of 1496 and 504 bytes each, the first fragment would have a fragmentation offset of 0 bytes and the second fragment would have a fragmentation offset of 1496 bytes and ih_flags_fragoff is therefore 187 (1496 / 8 = 187).


ih_ttl: "Time to live" for the packet. As a packet is routed to the destination, each router decrements the packet's ttl. When the ttl reaches 0, the router sends an "icmp unreachable" packet to the source. The ttl is designed to prevent packets that can't reach their destination from indefinitely bouncing around between routers. UDP's default TTL is 30:

#define UDP_TTL 30

Note that the Minix code also uses this value as a timeout value (in seconds). This code was written before the ttl field was redefined to be strictly a hope count. The original IP RFC defines the ttl field as the time to live in seconds.


ih_proto: The protocol of the ip packet. For example, if the packet is a udp packet, ih_proto will be 17. If the packet is a tcp packet, ih_proto will be 6.


ih_hdr_chk: Checksum for the header.


ih_src, ih_dst: Source and destination ip address of the ip packet.

             IP HEADER (as given by RFC 791)           

   



    0                   1                   2                   3   

    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 

   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

   |Version|  IHL  |Type of Service|          Total Length         |

   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

   |         Identification        |Flags|      Fragment Offset    |

   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

   | Time to Live  |   Protocol    |   Header Checksum             |

   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

   |                       Source Address                          |

   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

   |                    Destination Address                        |

   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

   |                    Options                    |    Padding    |

   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

If the packet is actually a fragment, call reassemble() to either store the fragment until the remaining fragments arrive or rebuild the original IP datagram from the other fragments already in ip_ass_table[].

The ih_flags_fragoff field has a size of 13 bits and is used by the receiver to determine the the fragment's place in the reassembly of the original ip packet. The ih_flags_fragoff field holds the fragment's starting byte position (divided by 8) within the original IP packet (which means that the first fragment's offset will be zero). The fragmentation mask (IH_FRAGOFF_MASK) is used to mask those 13 bits.

The More Fragments flag (IH_MORE_FRAGS) indicates whether or not the fragment is the last fragment of the original packet.

IH_FRAGOFF_MASK and IH_MORE_FRAGS are defined in /include/net/gen/ip_hdr.h:

#define IH_FRAGOFF_MASK 0x1fff
#define IH_MORE_FRAGS 0x2000


htons() / ntohs() / htonl() / ntohl()

From htons(3):

"htons() converts a 16-bit quantity from host byte order to network byte order."

Different CPU architectures group multiple bytes differently. For example, on a "little-endian" machine (an example of which is the Intel CPU), the value 0x1234 is stored in memory as 0x3412. However, on a "big-endian" machine, the value 0x1234 is stored in memory as 0x1234.

It is important that values in a header are sent across a network in a consistent manner independent of the architecture of the sending or receiving system. For this reason, a standard was chosen. The standard chosen was big-endian although it could have just as well been little-endian.

htons() is defined in /include/net/hton.h, as:
#define htons(x) (_tmp=(x), ((_tmp>>8) & 0xff) | ((_tmp<<8) & 0xff00))

ntohs() converts a 16-bit quantity from network byte order to host byte order, the reverse of htons().

htonl() and ntohl() are identical to htons() and ntohs() except that they convert 32-bit quantities instead of 16-bit quantities.

Processes generally supply header information when sending packets. The data in these fields is converted to the network format (i.e., big-endian) by the process before the process copies the data to the network service.

reassemble()

reassemble() reassembles a packet from its fragments. reassemble() either adds a fragment to ip_ass_table[] if all of the fragments have not already been received or, if all of the fragments have been received, reassembles the original ip packet from the fragments. For example, the following ip packet of length 3744 bytes is broken up in transit into 4 fragments of lengths 1480 bytes, 1480 bytes, and 784 bytes. The corresponding fragment offsets of the fragments are 0, 185, and 370 respectively (the "fragment offset" is the actual byte offset divided by 8). reassemble() will reassemble this original ip packet from the fragments it receives.



reassemble() is called by ip_port_arrive() and in turn calls find_ass_ent() and merge_frags().



A return value of NULL indicates that the packet to which the fragment belongs was not reassembled in its entirety or that the reassembly time exceeded the maximum time allowed (255 seconds in Minix).

If this point in the code has been reached, the packet has been successfully reassembled.

ptr2acc_data()

The macro ptr2acc_data is #define'd in inet/generic/buf.h as:

#define ptr2acc_data(/* acc_t * */ a) (bf_temporary_acc=(a), \
(&bf_temporary_acc->acc_buffer->buf_data_p[bf_temporary_acc-> \
acc_offset]))

ptr2acc_data() simply returns a pointer to the actual data within an accessor.

ptr2acc_data() is usually called so that the fields of a header (e.g., ip header) can be analyzed.

The expiration time of the packet is calculated using the ih_ttl (Time to Live) field of its header. As can be seen, there is a higher likelihood that it will be discarded. This code was written before ttl was redefined to be strictly a hop count. The original IP RFC defines TTL as the time to live in seconds.

HZ is #define'd in /include/minix/const.h:

#define HZ 60 /* clock freq (software settable on IBM-PC) */


get_time()

get_time() returns the number of clock ticks since reboot.

Several of the clients (eth, arp, ip, tcp, and udp) use get_time() to determine an appropriate timeout value for a given operation. For example, the arp code calls get_time() to determine an appropriate amount of time to wait for a response from an arp request before giving up.

Determine if the packet has the same destination ip address as the ip address of the ip port on which the packet arrived. This is one of the factors that determine whether a given ip file descriptor accepts the packet. Note that the default setting for an ip file descriptor is to accept both:

#define NWIO_DEFAULT (NWIO_EN_LOC | NWIO_EN_BROAD | NWIO_REMANY | \
NWIO_RWDATALL | NWIO_HDR_O_SPEC)

Ip file descriptors opened by the udp code are also configured to accept both.

The ih_proto field of the ip header is the protocol of the ip packet. For example, if the packet is a udp packet, ih_proto will be 17. If the packet is a tcp packet, ih_proto will be 6. The protocol of the packet is used to determine which linked lists of ip file descriptors associated with the ip port to search (see line 42472).

Since the NWUO_SHARED flag of an ip file descriptor is the most difficult to understand, here is a short description.

From ip(4):

"If the NWIO_SHARED flag is set, then multiple channels that all must specify NWIO_SHARED can use the same IP protocol, but incoming packets will be delivered to at most one channel."

An example best demonstrates the NWIO_SHARED flag.

Let's say there are three ip file descriptors (ip_fd_table[2], ip_fd_table[5], and ip_fd_table[9]) that have the same flags set; each is configured to share (i.e., their NWIO_SHARED flag is set) and each of the three ip file descriptors is configured for the udp protocol. The packet will only be delivered to ip_fd_table[9]; the packet will not be delivered to ip_fd_table[2] and ip_fd_table[5].

Let's also say that 2 other ip file descriptor, ip_fd_table[4] and ip_fd_table[6], have the same flags set with the exception of the NWIO_SHARED flag, which they do not have set. The packet will be delivered to ip_fd_table[4] and ip_fd_table[6] in addition to ip_fd_table[9].

Search through two of the ip port's linked lists of ip file descriptors. First, search through the linked list of file descriptors that have been configured to accept and send packets of any protocol type (e.g., udp, tcp). Second, search through the linked list associated with the protocol-type of the packet.

For the search of the protocol-specific linked list, continue (i.e., go to the next ip file descriptor) if the protocol of the packet and the ip port are not the same.

ip_pack_stat was determined on lines 42459-42461 and is either NWIO_EN_LOC or NWIO_EN_BROAD. Continue with the next ip file descriptor if the ip file descriptor is not configured appropriately.

From ip(4):

"NWIO_REMSPEC can be used to restrict communication to one remote host.
This host is taken from the nwio_rem field. If any remote host is to be
allowed, then NWIO_REMANY can be used."

The default setting for an ip file descriptor is to accept packets from any host:

#define NWIO_DEFAULT (NWIO_EN_LOC | NWIO_EN_BROAD | NWIO_REMANY | \
NWIO_RWDATALL | NWIO_HDR_O_SPEC)

From ip(4):

"If the NWIO_SHARED flag is set, then multiple channels that all must specify NWIO_SHARED can use the same IP protocol, but incoming packets will be delivered to at most one channel."

So, for example, if ip_fd_table[2], ip_fd_table[5], and ip_fd_table[9] are configured to share the same protocol and (if the NWIO_SHARED flag is configured for the ip file descriptors) the same source address, then the packet will only be delivered to ip_fd_table[9].

Note that first_fd is delivered the packet last. This is not an issue since there is no priority among the the ip file descriptors.

Incrementing acc_link of the first accessor forces packet2user() to create a duplicate of the packet.

packet2user() / ip

packet2user() attempts to pass a packet off to a higher layer (e.g., udp). If the ip file descriptor is not currently being read (i.e., the IFF_READ_IP flag in the if_flags field of the ip file descriptor is not set), packet2user() puts the packet at the end of its read queue and returns. Note that if the udp code opened the ip file descriptor, however, the udp code set the IFF_READ_IP flag during its initialization and that this flag remains set until the ip file descriptor is closed.

At most two ip file descriptors will receive the packet, one ip file descriptor in the ip_port_any linked list and one ip file descriptor in the ip_port[hash] that corresponds to the protocol of the incoming packet.

Incrementing acc_link of the first accessor forces packet2user() to create a duplicate of the packet.

packet2user() / ip

packet2user() attempts to pass a packet off to a higher layer (e.g., udp). If the ip file descriptor is not currently being read (i.e., the IFF_READ_IP flag in the if_flags field of the ip file descriptor is not set), packet2user() puts the packet at the end of its read queue and returns. Note that if the udp code opened the ip file descriptor, however, the udp code set the IFF_READ_IP flag during its initialization and that this flag remains set until the ip file descriptor is closed.

At this point in the code, both linked lists, ip_proto_any and ip_proto[hash], have been searched and the only ip file descriptor that hasn't been delivered the packet is the first non-shared ip file descriptor configured to receive the packet (if one exists). Lines 42511 - 42521 attempt to deliver the packet to this ip file descriptor.

If the ip file descriptor's IFF_READ_IP flag is not set, packet2user() places the packet in the ip file descriptor's read queue and returns. If the ip file descriptor's NWIO_RWDATONLY flag is set, packet2user() strips the ip packet's ip header. After these two checks are made, packet2user() calls a protocol-specific function that hands the packet off to the next higher layer (e.g., udp_ip_arrived()). However, if neither the IFF_READ_IP nor the NWIO_RWDATONLY flag are set, there is no point to calling packet2user() instead of directly calling the protocol-specific function.

If an ip file descriptor's NWIO_RWDATONLY flag is set, the process does not wish to be delivered the ip packet's ip header. The ip packet's ip header will be stripped off by packet2user().

Call the protocol-specific function that hands the packet off to the next-higher layer (e.g., udp_ip_arrived()).


htons() / ntohs() / htonl() / ntohl()

From htons(3):

"htons() converts a 16-bit quantity from host byte order to network byte order."

Different CPU architectures group multiple bytes differently. For example, on a "little-endian" machine (an example of which is the Intel CPU), the value 0x1234 is stored in memory as 0x3412. However, on a "big-endian" machine, the value 0x1234 is stored in memory as 0x1234.

It is important that values in a header are sent across a network in a consistent manner independent of the architecture of the sending or receiving system. For this reason, a standard was chosen. The standard chosen was big-endian although it could have just as well been little-endian.

htons() is defined in /include/net/hton.h, as:
#define htons(x) (_tmp=(x), ((_tmp>>8) & 0xff) | ((_tmp<<8) & 0xff00))

ntohs() converts a 16-bit quantity from network byte order to host byte order, the reverse of htons().

htonl() and ntohl() are identical to htons() and ntohs() except that they convert 32-bit quantities instead of 16-bit quantities.

Processes generally supply header information when sending packets. The data in these fields is converted to the network format (i.e., big-endian) by the process before the process copies the data to the network service.


udp_ip_arrived()

udp_ip_arrived() is called either (indirectly) from the ip code or from udp_put_data() and is one of the last functions called for a read request from a user process. udp_ip_arrived() does some checks (e.g., a checksum check) and figures out the destination udp file descriptor before calling udp_packet2user() to deliver the packet to the process that requested the read.

packet2user() / ip

packet2user() attempts to pass a packet off to a higher layer (e.g., udp). If the ip file descriptor is not currently being read (i.e., the IFF_READ_IP flag in the if_flags field of the ip file descriptor is not set), packet2user() puts the packet at the end of its read queue and returns. Note that if the udp code opened the ip file descriptor, however, the udp code set the IFF_READ_IP flag during its initialization and that this flag remains set until the ip file descriptor is closed.

The packet was not delivered to any non-shared ip file descriptors. Free the packet.

bf_afree()

After a chain of accessors is no longer needed, the chain (and not simply the single accessor passed as the parameter) can be freed by calling bf_free(). However, if either acc_linkC or buf_linkC of one of the accessors in the linked list is not equal to one (1), the entire chain will not be freed. For example, if buf_afree(acc1) is called for the following chain:



Then the resulting chain will be:



bf_afree() returns acc1 (accessors[63]) to acc_freelist (recall that acc_freelist is the linked list of acc_t's without an associated buffer). However, buffers512[127] cannot be freed because acc2 (accessors[64]) still references it.

bf_afree() is called after an accessor's associated data is no longer needed (for example, after a packet has been sent off by the ethernet driver).

ip_arrived()

Depending on the destination ip address of its second parameter,
ip_arrived(ip_port, pack) does one of several things:

1) If the destination ip address is the ip address of the ip port associated with the ethernet port, ip_arrived() calls ip_port_arrive() for the packet.

2) If the destination ip address is the ip address of another ip port, ip_arrived() also calls ip_port_arrived(). This time, however, the first argument passed to ip_port_arrived() is the other port. Note that for this to take place, an input route to the other ip port must exist.

3) If the destination ip address is not the address of another ip port but it is in the same network as another ip port, ip_arrived() sends the packet out the other interface. Again, an input route to the other ip port for this destination must exist.

4) If the destination ip address is not the address of another ip port and it is not in the same network as another ip port, ip_arrived() sends the packet out to the gateway for this network. Again, an input route (including the gateway) to the other ip port for this destination must exist.

5) If the destination ip address is not the ip address of the ip port but an input route for the destination exists and is associated with the same ip port as the packet arrived, an icmp redirect message is sent to the source (provided the source is on the same network) and the packet is then sent. If the source of the ip packet is not on the same network as the ip port, the packet is dropped.

If an ip packet arrives on an ethernet interface, ip_eth_arrived() strips off a packet's ethernet header before handing the packet off to ip_arrived().
udp read path

eth_arrive() 

  ip_eth_arrived() 



    if (unicast packet)

      ip_arrived()

    else if (ethernet broadcast packet)

      ip_arrived_broadcast()



      if (packet must be input routed)

        hand off packet to destination ip port

      else 

        ip_port_arrive() {

          packet2user()

            udp_ip_arrived() 

        }

bf_bufsize()

bf_bufsize() returns the total buffer size of a linked list of accessors (i.e., the sum of acc_length for the accessors in a linked list).

For a detailed description of the network service's buffer management, click here.

At this stage, the ip header is still on the packet. Therefore, the packet should obviously be at least as large as an ip header.

bf_align()

If data is not already packed and aligned, bf_align(acc, size, alignment) packs size (bf_align's second parameter) bytes from acc, bf_align()'s first parameter and a linked list of accessors (i.e., a packet), by calling bf_pack(). This packing is necessary to ensure that all of the fields from a header are easily accessed. For example, the ip code aligns a packet's header contained in the accessors before accessing the various ip header fields.

For a detailed description of the network service's buffer management, click here.

This is probably not necessary since bf_align() packs the buffer in addition to aligning the buffer.


bf_packIffLess()

If the data in a linked list of accessors is less than min_len (the second parameter), bf_packIffLess(pack, min_len) packs the data by calling bf_pack().

bf_packIffLess() is often called to ensure that a packet's header is in a single contiguous buffer so that the individual fields of the header can be easily accessed.

For a detailed description of the network service's buffer management, click here.

ptr2acc_data()

The macro ptr2acc_data is #define'd in inet/generic/buf.h as:

#define ptr2acc_data(/* acc_t * */ a) (bf_temporary_acc=(a), \
(&bf_temporary_acc->acc_buffer->buf_data_p[bf_temporary_acc-> \
acc_offset]))

ptr2acc_data() simply returns a pointer to the actual data within an accessor.

ptr2acc_data() is usually called so that the fields of a header (e.g., ip header) can be analyzed.

The lower 4 bits of ih_vers_ihl is the length of the header plus options (if there are any) shifted by 2 bit positions (i.e., its actual length is 4 times as great as the value stored in ih_vers_ihl). An example of an option is a router list that a packet should follow to its destination.

The upper four bits is the version number (e.g., IPv4).

The block that preceded this block ensured that the ip header (but not the ip header options) was in one contiguous memory block.

In this case, the ip header has options. Ensure that the ip header and all ip header options are in one contiguous memory block.

bf_align()

If data is not already packed and aligned, bf_align(acc, size, alignment) packs size (bf_align's second parameter) bytes from acc, bf_align()'s first parameter and a linked list of accessors (i.e., a packet), by calling bf_pack(). This packing is necessary to ensure that all of the fields from a header are easily accessed. For example, the ip code aligns a packet's header contained in the accessors before accessing the various ip header fields.

For a detailed description of the network service's buffer management, click here.

bf_packIffLess()

If the data in a linked list of accessors is less than min_len (the second parameter), bf_packIffLess(pack, min_len) packs the data by calling bf_pack().

bf_packIffLess() is often called to ensure that a packet's header is in a single contiguous buffer so that the individual fields of the header can be easily accessed.

For a detailed description of the network service's buffer management, click here.

ptr2acc_data()

The macro ptr2acc_data is #define'd in inet/generic/buf.h as:

#define ptr2acc_data(/* acc_t * */ a) (bf_temporary_acc=(a), \
(&bf_temporary_acc->acc_buffer->buf_data_p[bf_temporary_acc-> \
acc_offset]))

ptr2acc_data() simply returns a pointer to the actual data within an accessor.

ptr2acc_data() is usually called so that the fields of a header (e.g., ip header) can be analyzed.

htons() / ntohs() / htonl() / ntohl()

From htons(3):

"htons() converts a 16-bit quantity from host byte order to network byte order."

Different CPU architectures group multiple bytes differently. For example, on a "little-endian" machine (an example of which is the Intel CPU), the value 0x1234 is stored in memory as 0x3412. However, on a "big-endian" machine, the value 0x1234 is stored in memory as 0x1234.

It is important that values in a header are sent across a network in a consistent manner independent of the architecture of the sending or receiving system. For this reason, a standard was chosen. The standard chosen was big-endian although it could have just as well been little-endian.

htons() is defined in /include/net/hton.h, as:
#define htons(x) (_tmp=(x), ((_tmp>>8) & 0xff) | ((_tmp<<8) & 0xff00))

ntohs() converts a 16-bit quantity from network byte order to host byte order, the reverse of htons().

htonl() and ntohl() are identical to htons() and ntohs() except that they convert 32-bit quantities instead of 16-bit quantities.

Processes generally supply header information when sending packets. The data in these fields is converted to the network format (i.e., big-endian) by the process before the process copies the data to the network service.

If the size of the packet (or fragment) as advertised in the header is less than the size of the packet received, trim the packet to reflect the size as advertised in the header. It appears that this will never be the case.

ip_frag_chk()

ip_frag_chk(pack) performs a few checks on the packet pack, ip_frag_chk()'s only parameter. For example, ip_frag_chk() verifies that the checksum of the ip header is zero.

ip_frag_chk() returns 0 on failure.

Lines 42595-42606 determine if the destination ip address of the packet is for the local address or the ip broadcast address of the ip port. For both cases, ip_port_arrive() is called. If the desination ip address of the packet is neither the ip address of the ip port nor the ip broadcast address, the packet must be routed.

ip_port_arrive()

For a given packet, ip_port_arrive() finds the ip file descriptors that are interested in the packet. ip_port_arrive() then hands the packet off to the higher layer (e.g., udp layer) by calling either packet2user() or a protocol-specific function (e.g., udp_ip_arrived()).

eth_arrive() is the function analogous to ip_port_arrive() on the ethernet layer. eth_arrive() tries to find interested ethernet file descriptors for a given packet.

broadcast_dst()

broadcast_dst(ip_port, dest) returns TRUE if dest, the second parameter of ip_broadcast_dst(), is the broadcast address of the ip port ip_port, the first parameter.

Which addresses are broadcast addresses for a given ip port is best shown with an example:

If an ip port has an ip address/subnet pair of 192.168.1.5/255.255.255.252, the following ip addresses are considered to be broadcast addresses:

192.168.1.7 (the broadcast address for the given subnet)
192.168.1.255 (the broadcast address for the address's class C network)
255.255.255.255

If BSD rules apply (i.e., iff IP_42BSD_BCAST is set), the following ip addresses are also considered to be broadcast addresses:

192.168.1.4 (the network address for the given subnet)
192.168.1.0 (the network address for the address's class C network)

ip_port_arrive()

For a given packet, ip_port_arrive() finds the ip file descriptors that are interested in the packet. ip_port_arrive() then hands the packet off to the higher layer (e.g., udp layer) by calling either packet2user() or a protocol-specific function (e.g., udp_ip_arrived()).

eth_arrive() is the function analogous to ip_port_arrive() on the ethernet layer. eth_arrive() tries to find interested ethernet file descriptors for a given packet.

It is possible that the packet must be routed to another system.

The packet's ttl has expired. Send an "icmp undeliverable" packet.

icmp_snd_time_exceeded()

icmp_snd_time_exceeded() sends an ICMP_TYPE_TIME_EXCEEDED icmp message. ICMP_TYPE_TIME_EXCEEDED messages are sent when either a packet's TTL timer has expired or if some fragments of the original packet were not received in time to be reassembled by the destination system.

Since the ttl is a hop count and since the packet was not destined for this system but must be sent to another system, decrement the ttl.

The TTL has changed. The checksum for the header must reflect this change.

Note that since the ttl is decremented by every router along an ip packet's path to the destination, the checksum of the ip packet must be recalculated by each router through which the packet passes.


ip_hdr_chksum()

ip_hdr_chksum() sets the ih_hdr_chk field of an ip header with the checksum of the ip header (minus the checksum field). This checksum is obtained from oneC_sum().

ip_nettype()

ip_nettype(ipaddr) returns the network type (which will be of type nettype_t) of ipaddr, the only parameter to ip_nettype().

The nettype_t enum typedef is declared in inet/generic/ip_int.h. Each type's associated ip address range is included in the comments.

 typedef enum nettype

 {

          IPNT_ZERO,                 /* 0.xx.xx.xx */

          IPNT_CLASS_A,              /* 1.xx.xx.xx .. 126.xx.xx.xx */

          IPNT_LOCAL,                /* 127.xx.xx.xx */

          IPNT_CLASS_B,              /* 128.xx.xx.xx .. 191.xx.xx.xx */

          IPNT_CLASS_C,              /* 192.xx.xx.xx .. 223.xx.xx.xx */

          IPNT_CLASS_D,              /* 224.xx.xx.xx .. 239.xx.xx.xx */

          IPNT_CLASS_E,              /* 240.xx.xx.xx .. 247.xx.xx.xx */

          IPNT_MARTIAN,              /* 248.xx.xx.xx .. 254.xx.xx.xx +  */

          IPNT_BROADCAST             /* 255.255.255.255 */

 } nettype_t;

Only class A, B, and C packets can be routed.

Packets destined for class D and E ip addresses are simply dropped. For all other packets, the source is sent an icmp unreachable packet.

Class D ip addresses are used for multicasting and Class E ip addresses are used in research.


bf_afree()

After a chain of accessors is no longer needed, the chain (and not simply the single accessor passed as the parameter) can be freed by calling bf_free(). However, if either acc_linkC or buf_linkC of one of the accessors in the linked list is not equal to one (1), the entire chain will not be freed. For example, if buf_afree(acc1) is called for the following chain:



Then the resulting chain will be:



bf_afree() returns acc1 (accessors[63]) to acc_freelist (recall that acc_freelist is the linked list of acc_t's without an associated buffer). However, buffers512[127] cannot be freed because acc2 (accessors[64]) still references it.

bf_afree() is called after an accessor's associated data is no longer needed (for example, after a packet has been sent off by the ethernet driver).

icmp_snd_unreachable()

icmp_snd_unreachable(port_nr, pack, code) builds an icmp unreachable packet (partially using the ip packet pack, icmp_snd_unreachable()'s second parameter) and then places the icmp unreachable packet in the outgoing queue. Icmp unreachable packets are sent if the network, host, or port number specified by the ip packet pack is unreachable.

The function first calls icmp_err_pack() to build a generic icmp packet, sets the ih_type field of the icmp header to ICMP_TYPE_DST_UNRCH and recalibrates the checksum (since the type and code fields of the icmp header have changed) of the icmp header before placing the packet in the icmp port's write queue.

Note that the network service handles two types of routing, output routing and input routing. Output routing handles the routing of outgoing packets. Input routing, on the other hand, handles the routing of packets received on the ethernet or psip ports that are not destined for the local machine.


iroute_frag()

iroute_frag(port_nr, dest) first looks in the input route cache (i.e., iroute_hash_table[][]) for a route for the network to which dest, iroute_frag()'s second parameter, belongs and if it doesn't find the route in the cache, looks for the route in the main input routing table (i.e., iroute_table[]).

If iroute_frag() doesn't find the route in the cache or the routing table, it returns NULL. If iroute_frag() cannot find the route in the cache but finds the route in the main routing table, it places the route in the cache.

If a route to the network couldn't be found in the main input routing table or the route to the network was labeled as unreachable, send the source of the packet an icmp unreachable packet.

icmp_snd_unreachable()

icmp_snd_unreachable(port_nr, pack, code) builds an icmp unreachable packet (partially using the ip packet pack, icmp_snd_unreachable()'s second parameter) and then places the icmp unreachable packet in the outgoing queue. Icmp unreachable packets are sent if the network, host, or port number specified by the ip packet pack is unreachable.

The function first calls icmp_err_pack() to build a generic icmp packet, sets the ih_type field of the icmp header to ICMP_TYPE_DST_UNRCH and recalibrates the checksum (since the type and code fields of the icmp header have changed) of the icmp header before placing the packet in the icmp port's write queue.

The irt_port field of an input route for a given network holds the ip port to which the packet should be routed.

Send the packet out the appropriate ip port. If the ip port is associated with an ethernet port (as opposed to a psip port), ip_dev_send for the ip port will be ipeth_send().


ipeth_send()

ipeth_send() is called (indirectly) by ip_send() to send out a packet to a destination address on the same subnet as the ip port from which it is sent or to send out a packet to a broadcast address. ipeth_send() first creates an ethernet header to prepend to the ip packet and then, if there are no packets waiting to be sent out, calls eth_send() in an attempt to send the packet to the ethernet task immediately. If eth_send() is not able to send the ethernet packet immediately, eth_write() is called to queue the packet. If there are already ethernet packets waiting to be sent out, eth_send() and eth_write() are not called and the packet is queued (i.e., placed in the de_q_head queue of the ip port).

If the irt_gateway field of the input route is null, the destination must be on the same network.

To enable this passing of packets between two interfaces (e.g., between two ip ports), the add_route utility can be used:

"The command

add_route -i -g 0.0.0.0 -d 192.31.231.0 -m 1 -n 255.255.255.0 -I /dev/ip0

adds a route to the directly attached ethernet. A packet for 192.31.231.1
that arrives at interface ip2 will be routed to ip0 and ARP will
be used to find the ethernet address associated with 192.31.231.1."

If the destination ip address of the packet is the ip address of the ip port to which the packet is routed, call ip_port_arrive() to hand the packet off to the ip port. An example of this scenario is if a system has two ethernet ports, ethernet 1 and ethernet 2, and an ip packet arrives on ethernet 1 and the ip packet is destined for the ip address of the ip port associated with ethernet 2. Note that an entry in the input routing table must exist for this routing to occur.

ip_port_arrive()

For a given packet, ip_port_arrive() finds the ip file descriptors that are interested in the packet. ip_port_arrive() then hands the packet off to the higher layer (e.g., udp layer) by calling either packet2user() or a protocol-specific function (e.g., udp_ip_arrived()).

eth_arrive() is the function analogous to ip_port_arrive() on the ethernet layer. eth_arrive() tries to find interested ethernet file descriptors for a given packet.

If the destination ip address of the packet is a network address (as opposed to the ip address of a single host), interpret the address as the broadcast address if the network service follows the BSD convention for broadcast addresses (i.e., IP_42BSD_BCAST is TRUE). If the network service does not follow the BSD convention, send the source of the packet an icmp unreachable packet.

This function is not in any of the files. If IP_42BSD_BCAST is not #define'd, there's a problem.

The packet is destined for the broadcast address of a network. For example, if a network in the input routing table has a network address of 204.140.1.0 and a subnet mask of 255.255.255.0, the broadcast address of the network is 204.140.1.255:

204.140.1.0 | ~(255.255.255.0)
= 204.140.1.0 | 0.0.0.255
= 204.140.1.255

The broadcast variable is used on line 42678.

The packet is a unicast packet.

Send the packet out the appropriate ip port. If the ip port is associated with an ethernet port (as opposed to a psip port), ip_dev_send for the ip port will be ipeth_send().


ipeth_send()

ipeth_send() is called (indirectly) by ip_send() to send out a packet to a destination address on the same subnet as the ip port from which it is sent or to send out a packet to a broadcast address. ipeth_send() first creates an ethernet header to prepend to the ip packet and then, if there are no packets waiting to be sent out, calls eth_send() in an attempt to send the packet to the ethernet task immediately. If eth_send() is not able to send the ethernet packet immediately, eth_write() is called to queue the packet. If there are already ethernet packets waiting to be sent out, eth_send() and eth_write() are not called and the packet is queued (i.e., placed in the de_q_head queue of the ip port).

The packet will be sent out the same interface on which it was received. Obviously, this isn't ideal; in the future, packets destined for the same ip address as this packet should be redirected elsewhere. For a good description of redirect messages and when they are sent, click here.

If there is no gateway for the input route, free the packet.

bf_afree()

After a chain of accessors is no longer needed, the chain (and not simply the single accessor passed as the parameter) can be freed by calling bf_free(). However, if either acc_linkC or buf_linkC of one of the accessors in the linked list is not equal to one (1), the entire chain will not be freed. For example, if buf_afree(acc1) is called for the following chain:



Then the resulting chain will be:



bf_afree() returns acc1 (accessors[63]) to acc_freelist (recall that acc_freelist is the linked list of acc_t's without an associated buffer). However, buffers512[127] cannot be freed because acc2 (accessors[64]) still references it.

bf_afree() is called after an accessor's associated data is no longer needed (for example, after a packet has been sent off by the ethernet driver).

If the source ip address of the packet and the ip address of the ip port are in the same network, icmp_snd_redirect() sends the source an icmp redirect message and then sends the packet (lines 42722-42723).

icmp_snd_redirect()

icmp_snd_redirect(port_nr, pack, code) builds an icmp redirect packet (partially using the ip packet pack, icmp_snd_redirect()'s second parameter) and then places the icmp redirect packet in the outgoing queue.

The function first calls icmp_err_pack() to build a generic icmp packet, sets the ih_type field of the icmp header to ICMP_TYPE_REDIRECT and recalibrates the checksum (since the type, code, and gateway fields of the icmp header have changed) of the icmp header before placing the icmp packet in the icmp port's write queue.

If the source of the packet was not in the same network as the ip port, discard the packet.

After sending out the icmp redirect message, send the packet out the same interface on which it arrived. If the ip port is associated with an ethernet port (as opposed to a psip port), the ip_dev_send field of the ip port was set to ipeth_send().


ipeth_send()

ipeth_send() is called (indirectly) by ip_send() to send out a packet to a destination address on the same subnet as the ip port from which it is sent or to send out a packet to a broadcast address. ipeth_send() first creates an ethernet header to prepend to the ip packet and then, if there are no packets waiting to be sent out, calls eth_send() in an attempt to send the packet to the ethernet task immediately. If eth_send() is not able to send the ethernet packet immediately, eth_write() is called to queue the packet. If there are already ethernet packets waiting to be sent out, eth_send() and eth_write() are not called and the packet is queued (i.e., placed in the de_q_head queue of the ip port).

ip_arrived_broadcast()

If a packet arrives on an ethernet interface, ip_arrived_broadcast() is called from ip_eth_arrived() (instead of ip_arrived()) if the arriving ethernet packet has the broadcast ethernet address (i.e., ff:ff:ff:ff:ff:ff). ip_arrived_broadcast() performs some checks that include verifying that the destination ip address (in addition to the destination ethernet address) is the broadcast address.udp read path

eth_arrive() 

  ip_eth_arrived() 



    if (unicast packet)

      ip_arrived()

    else if (ethernet broadcast packet)

      ip_arrived_broadcast()



      if (packet must be input routed)

        hand off packet to destination ip port

      else 

        ip_port_arrive() {

          packet2user()

            udp_ip_arrived() 

        }

bf_bufsize()

bf_bufsize() returns the total buffer size of a linked list of accessors (i.e., the sum of acc_length for the accessors in a linked list).

For a detailed description of the network service's buffer management, click here.

If the ip packet isn't even as big as the minimum ip header, there's a serious problem.

Lines 42743 pack and align the buffer so that the ip header can be extracted on line 42747.

bf_align()

If data is not already packed and aligned, bf_align(acc, size, alignment) packs size (bf_align's second parameter) bytes from acc, bf_align()'s first parameter and a linked list of accessors (i.e., a packet), by calling bf_pack(). This packing is necessary to ensure that all of the fields from a header are easily accessed. For example, the ip code aligns a packet's header contained in the accessors before accessing the various ip header fields.

For a detailed description of the network service's buffer management, click here.

bf_packIffLess()

If the data in a linked list of accessors is less than min_len (the second parameter), bf_packIffLess(pack, min_len) packs the data by calling bf_pack().

bf_packIffLess() is often called to ensure that a packet's header is in a single contiguous buffer so that the individual fields of the header can be easily accessed.

For a detailed description of the network service's buffer management, click here.

ptr2acc_data()

The macro ptr2acc_data is #define'd in inet/generic/buf.h as:

#define ptr2acc_data(/* acc_t * */ a) (bf_temporary_acc=(a), \
(&bf_temporary_acc->acc_buffer->buf_data_p[bf_temporary_acc-> \
acc_offset]))

ptr2acc_data() simply returns a pointer to the actual data within an accessor.

ptr2acc_data() is usually called so that the fields of a header (e.g., ip header) can be analyzed.

If the ip header includes ip options, it will be larger than the minimum header size and the buffer must be repacked and realigned and the ip header must be extracted again from the buffer.

The lower 4 bits of ih_vers_ihl is the length of the header plus options (if there are any) shifted by 2 bit positions (i.e., its actual length is 4 times as great as the value stored in ih_vers_ihl). An example of an option is a router list that a packet should follow to its destination.

The upper four bits iof ih_vers_ihl s the version number (e.g., IPv4).

bf_align()

If data is not already packed and aligned, bf_align(acc, size, alignment) packs size (bf_align's second parameter) bytes from acc, bf_align()'s first parameter and a linked list of accessors (i.e., a packet), by calling bf_pack(). This packing is necessary to ensure that all of the fields from a header are easily accessed. For example, the ip code aligns a packet's header contained in the accessors before accessing the various ip header fields.

For a detailed description of the network service's buffer management, click here.

bf_packIffLess()

If the data in a linked list of accessors is less than min_len (the second parameter), bf_packIffLess(pack, min_len) packs the data by calling bf_pack().

bf_packIffLess() is often called to ensure that a packet's header is in a single contiguous buffer so that the individual fields of the header can be easily accessed.

For a detailed description of the network service's buffer management, click here.

ptr2acc_data()

The macro ptr2acc_data is #define'd in inet/generic/buf.h as:

#define ptr2acc_data(/* acc_t * */ a) (bf_temporary_acc=(a), \
(&bf_temporary_acc->acc_buffer->buf_data_p[bf_temporary_acc-> \
acc_offset]))

ptr2acc_data() simply returns a pointer to the actual data within an accessor.

ptr2acc_data() is usually called so that the fields of a header (e.g., ip header) can be analyzed.

ih_length is the length of the entire ip packet, including the ip header. If this total length is less than the length of the buffer (line 42760), cut the buffer to size (lines 42761-42765).


htons() / ntohs() / htonl() / ntohl()

From htons(3):

"htons() converts a 16-bit quantity from host byte order to network byte order."

Different CPU architectures group multiple bytes differently. For example, on a "little-endian" machine (an example of which is the Intel CPU), the value 0x1234 is stored in memory as 0x3412. However, on a "big-endian" machine, the value 0x1234 is stored in memory as 0x1234.

It is important that values in a header are sent across a network in a consistent manner independent of the architecture of the sending or receiving system. For this reason, a standard was chosen. The standard chosen was big-endian although it could have just as well been little-endian.

htons() is defined in /include/net/hton.h, as:
#define htons(x) (_tmp=(x), ((_tmp>>8) & 0xff) | ((_tmp<<8) & 0xff00))

ntohs() converts a 16-bit quantity from network byte order to host byte order, the reverse of htons().

htonl() and ntohl() are identical to htons() and ntohs() except that they convert 32-bit quantities instead of 16-bit quantities.

Processes generally supply header information when sending packets. The data in these fields is converted to the network format (i.e., big-endian) by the process before the process copies the data to the network service.

If the packet length advertised by its header is less than the size of the packet received, the packet is trimmed to reflect the length advertised by the header.

bf_cut()

If a section of a linked list needs to be duplicated, bf_cut(data, offset, length) is called. For example, if a section of length 50 starting at an offset of 75 of the linked list below needs to be duplicated, bf_cut(data, 75, 50) is called:



Note that the original linked list remains unchanged and that acc_linkC for all the accessors in the new linked list is one.

If length (the second parameter) is zero, simply duplicate the first accessor in the linked list but set acc_length=0 and acc_next=null. In other words, create a linked list of length one accessor whose acc_length is 0.

bf_cut() is used in a number of scenarios, including cutting a received ethernet packet to size.

For a full description of the network service's buffer management, click here.

bf_afree()

After a chain of accessors is no longer needed, the chain (and not simply the single accessor passed as the parameter) can be freed by calling bf_free(). However, if either acc_linkC or buf_linkC of one of the accessors in the linked list is not equal to one (1), the entire chain will not be freed. For example, if buf_afree(acc1) is called for the following chain:



Then the resulting chain will be:



bf_afree() returns acc1 (accessors[63]) to acc_freelist (recall that acc_freelist is the linked list of acc_t's without an associated buffer). However, buffers512[127] cannot be freed because acc2 (accessors[64]) still references it.

bf_afree() is called after an accessor's associated data is no longer needed (for example, after a packet has been sent off by the ethernet driver).

ip_frag_chk()

ip_frag_chk(pack) performs a few checks on the packet pack, ip_frag_chk()'s only parameter. For example, ip_frag_chk() verifies that the checksum of the ip header is zero.

ip_frag_chk() returns 0 on failure.

bf_afree()

After a chain of accessors is no longer needed, the chain (and not simply the single accessor passed as the parameter) can be freed by calling bf_free(). However, if either acc_linkC or buf_linkC of one of the accessors in the linked list is not equal to one (1), the entire chain will not be freed. For example, if buf_afree(acc1) is called for the following chain:



Then the resulting chain will be:



bf_afree() returns acc1 (accessors[63]) to acc_freelist (recall that acc_freelist is the linked list of acc_t's without an associated buffer). However, buffers512[127] cannot be freed because acc2 (accessors[64]) still references it.

bf_afree() is called after an accessor's associated data is no longer needed (for example, after a packet has been sent off by the ethernet driver).

Verify that the ip address of the packet is a broadcast address. The ethernet address of the ethernet packet was already determined to be a broadcast address.


broadcast_dst()

broadcast_dst(ip_port, dest) returns TRUE if dest, the second parameter of ip_broadcast_dst(), is the broadcast address of the ip port ip_port, the first parameter.

Which addresses are broadcast addresses for a given ip port is best shown with an example:

If an ip port has an ip address/subnet pair of 192.168.1.5/255.255.255.252, the following ip addresses are considered to be broadcast addresses:

192.168.1.7 (the broadcast address for the given subnet)
192.168.1.255 (the broadcast address for the address's class C network)
255.255.255.255

If BSD rules apply (i.e., iff IP_42BSD_BCAST is set), the following ip addresses are also considered to be broadcast addresses:

192.168.1.4 (the network address for the given subnet)
192.168.1.0 (the network address for the address's class C network)

ip_port_arrive()

For a given packet, ip_port_arrive() finds the ip file descriptors that are interested in the packet. ip_port_arrive() then hands the packet off to the higher layer (e.g., udp layer) by calling either packet2user() or a protocol-specific function (e.g., udp_ip_arrived()).

eth_arrive() is the function analogous to ip_port_arrive() on the ethernet layer. eth_arrive() tries to find interested ethernet file descriptors for a given packet.

broadcast_dst()

broadcast_dst(ip_port, dest) returns TRUE if dest, the second parameter of ip_broadcast_dst(), is the broadcast address of the ip port ip_port, the first parameter.

Which addresses are broadcast addresses for a given ip port is best shown with an example:

If an ip port has an ip address/subnet pair of 192.168.1.5/255.255.255.252, the following ip addresses are considered to be broadcast addresses:

192.168.1.7 (the broadcast address for the given subnet)
192.168.1.255 (the broadcast address for the address's class C network)
255.255.255.255

If BSD rules apply (i.e., iff IP_42BSD_BCAST is set), the following ip addresses are also considered to be broadcast addresses:

192.168.1.4 (the network address for the given subnet)
192.168.1.0 (the network address for the address's class C network)

If the first byte (in binary) of the destination address is "1110", the address is a multicast address. In other words, the range "224.0.0.0" through "239.255.255.255" (i.e., "Class D" addresses) are multicast addresses.

Multicast addresses are treated here as broadcast addresses.


htons() / ntohs() / htonl() / ntohl()

From htons(3):

"htons() converts a 16-bit quantity from host byte order to network byte order."

Different CPU architectures group multiple bytes differently. For example, on a "little-endian" machine (an example of which is the Intel CPU), the value 0x1234 is stored in memory as 0x3412. However, on a "big-endian" machine, the value 0x1234 is stored in memory as 0x1234.

It is important that values in a header are sent across a network in a consistent manner independent of the architecture of the sending or receiving system. For this reason, a standard was chosen. The standard chosen was big-endian although it could have just as well been little-endian.

htons() is defined in /include/net/hton.h, as:
#define htons(x) (_tmp=(x), ((_tmp>>8) & 0xff) | ((_tmp<<8) & 0xff00))

ntohs() converts a 16-bit quantity from network byte order to host byte order, the reverse of htons().

htonl() and ntohl() are identical to htons() and ntohs() except that they convert 32-bit quantities instead of 16-bit quantities.

Processes generally supply header information when sending packets. The data in these fields is converted to the network format (i.e., big-endian) by the process before the process copies the data to the network service.

The netmask is simply a reflection of the class to which the ip address belongs. For example, if the ip address is 194.77.33.5, then it is a class C address and its netmask is therefore 255.255.255.0. See ip_nettype() for more information.

Determine if the destination ip address and the ip address of the ip port are in the same network. If the two addresses are part of the same network, the condition below will be false. For example, 192.168.1.1 and 192.168.1.255 are in the same network (see calculation below). Note that 192.168.1.x is a class C network - in other words, the netmask is 255.255.255.0.

(192.168.1.1 ^ 192.168.1.255) & 255.255.255.0 =
0.0.0.254 & 255.255.255.0 = 0 (and therefore the condition is false)

(note that "^" is the exclusive-or (XOR) operator)

If the two addresses are not part of the same class network, determine whether the address is 255.255.255.255 or 0.0.0.0 (if BSD rules are followed).

If the address is 255.255.255.255, this is considered to be a broadcast packet.

ipaddr_t is declared in include/net/gen/in.h:

typedef u32_t ipaddr_t;

Casting (-1) to an ipaddr_t produces a value of 0xffffffff (255.255.255.255).


htons() / ntohs() / htonl() / ntohl()

From htons(3):

"htons() converts a 16-bit quantity from host byte order to network byte order."

Different CPU architectures group multiple bytes differently. For example, on a "little-endian" machine (an example of which is the Intel CPU), the value 0x1234 is stored in memory as 0x3412. However, on a "big-endian" machine, the value 0x1234 is stored in memory as 0x1234.

It is important that values in a header are sent across a network in a consistent manner independent of the architecture of the sending or receiving system. For this reason, a standard was chosen. The standard chosen was big-endian although it could have just as well been little-endian.

htons() is defined in /include/net/hton.h, as:
#define htons(x) (_tmp=(x), ((_tmp>>8) & 0xff) | ((_tmp<<8) & 0xff00))

ntohs() converts a 16-bit quantity from network byte order to host byte order, the reverse of htons().

htonl() and ntohl() are identical to htons() and ntohs() except that they convert 32-bit quantities instead of 16-bit quantities.

Processes generally supply header information when sending packets. The data in these fields is converted to the network format (i.e., big-endian) by the process before the process copies the data to the network service.

If BSD rules apply, ip address 0.0.0.0 is also a broadcast address.

Using the subnet mask this time (instead of the netmask - see line 42808), determine if the destination address is in the same (sub)network as the ip address of the ip port. Again, the condition below will be false if the two addresses are part of the same network (or, actually, subnet in this case).

Accept "network.-1" as a broadcast address. For example, 192.168.1.255 (which is a class C address and therfore has a netmask of 255.255.255.0) is a broadcast address if BSD rules apply. Note that this will be a broadcast address even if the subnet mask is not 255.255.255.0. In my (Andrew's) opinion, this is a little odd.

If BSD rules apply, accept "network.0" as a broadcast address. For example, 192.168.1.0 (which is a class C address and therefore has a netmask of 255.255.255.0) is a broadcast address if BSD rules apply.

This is the common case of the broadcast address. If the destination address is 192.168.1.7 and the ip port/subnet mask pair is 192.168.1.5/255.255.255.252, the destination address is the broadcast address:

192.168.1.7 & ~(255.255.255.252) = 192.168.1.7 & 0.0.0.3 =
0.0.0.2 ?= ~(255.255.255.252) = 0.0.0.2

The condition is true and therefore 192.168.1.7 is the broadcast address for 192.168.1.5/255.255.255.252.

Note that 192.168.1.3 and 192.168.1.11 will not be broadcast addresses for 192.168.1.5/255.255.255.252.

If BSD rules apply, accept "network.subnet.-1". In other words (and using the example above), 192.168.1.4 will be accepted as the broadcast address if 192.168.1.5/255.255.255.252 is the ip address/subnetmask for the ip port.

ip_process_loopb()

If a packet is either sent (i.e., written) to the ip address of the ip port out of which the packet is sent or sent to the loopback address, ip_send() calls ev_enqueue() with its second argument set to a reference of ip_process_loopb(). The next time that the event queue is processed, ip_process_loopb() will be called.

ip_process_loopb() calls ip_arrived() for every ip packet in the ip port's ip_loopb_head queue.

The packets in the ip port's ip_loopb_head queue are linked together by their acc_ext_link field.

ip_arrived()

Depending on the destination ip address of its second parameter,
ip_arrived(ip_port, pack) does one of several things:

1) If the destination ip address is the ip address of the ip port associated with the ethernet port, ip_arrived() calls ip_port_arrive() for the packet.

2) If the destination ip address is the ip address of another ip port, ip_arrived() also calls ip_port_arrived(). This time, however, the first argument passed to ip_port_arrived() is the other port. Note that for this to take place, an input route to the other ip port must exist.

3) If the destination ip address is not the address of another ip port but it is in the same network as another ip port, ip_arrived() sends the packet out the other interface. Again, an input route to the other ip port for this destination must exist.

4) If the destination ip address is not the address of another ip port and it is not in the same network as another ip port, ip_arrived() sends the packet out to the gateway for this network. Again, an input route (including the gateway) to the other ip port for this destination must exist.

5) If the destination ip address is not the ip address of the ip port but an input route for the destination exists and is associated with the same ip port as the packet arrived, an icmp redirect message is sent to the source (provided the source is on the same network) and the packet is then sent. If the source of the ip packet is not on the same network as the ip port, the packet is dropped.

If an ip packet arrives on an ethernet interface, ip_eth_arrived() strips off a packet's ethernet header before handing the packet off to ip_arrived().